csif: Andor SIF Parser in C

Features

Project Structure

$ tree . -L 3
.
├── build
│ ├── bin
│ │ ├── debug_detail_sif # Independent debug tool
│ │ ├── debug_sif # Dependent debug tool 
│ │ └── read_sif # Main example executable
│ ├── lib
│ │ ├── libsifparser.a # Static library
│ │ └── libsifparser.so* # Shared library
│ └── Release
│ └── sifaddon.node # Node.js addon
├── include
│ ├── sif_parser.h # Main parsing library
│ ├── sif_utils.h # Utility functions
│ └── sif_json.h # JSON output functions
└── src
 ├── sif_parser.c # Core parsing implementation
 ├── sif_utils.c # Utility implementations
 ├── sif_json.c # JSON output implementation
 ├── binding.cc # Node.js addon binding
 └── main.c # Example usage

Quick Start

Building the Library

# Clone and build
git clone <repository-url>
cd csif
mkdir build && cd build
cmake ..
make -j4

Node.js Addon (npm)

# Build Node.js addon
npm install
npm run build
# Or manually with node-gyp
npx node-gyp configure
npx node-gyp build

Basic Usage

#include "sif_parser.h"
int main() {
 SifFile sif_file;
 
 // Open and parse SIF file
 if (sif_open_file("data.sif", &sif_file) == 0) {
 // Access image data
 float* frame_data = sif_get_frame_data(&sif_file, 0);
 
 // Get calibration data
 int calib_size;
 double* calibration = retrieve_calibration(&sif_file.info, &calib_size);
 
 // Clean up
 sif_close(&sif_file);
 }
 
 return 0;
}

Command Line Tools

# Basic file reading
./bin/read_sif /path/to/your/file.sif
# Quiet mode (only essential output)
./bin/read_sif /path/to/file.sif -q
# Verbose mode (detailed parsing info)
./bin/read_sif /path/to/file.sif -v
# Debug mode (all internal information)
./bin/read_sif /path/to/file.sif -d

Output Levels

API Overview

Core Functions

// File operations
int sif_open_file(const char* filename, SifFile* sif_file);
int sif_open(FILE* fp, SifFile* sif_file);
void sif_close(SifFile* sif_file);
// Data access
float* sif_get_frame_data(SifFile* sif_file, int frame_index);
int sif_load_all_frames(SifFile* sif_file, int byte_swap);
// Calibration
double* retrieve_calibration(SifInfo* info, int* calibration_size);
// Output control
void sif_set_verbose_level(SifVerboseLevel level);

Key Data Structures

typedef struct {
 char detector_type[64];
 int number_of_frames;
 int image_width, image_height;
 float exposure_time;
 double calibration_coefficients[MAX_CALIBRATION_COEFFS];
 int calibration_coeff_count;
 // ... more fields
} SifInfo;
typedef struct {
 SifInfo info;
 SifTile* tiles;
 int tile_count;
 FILE* file_ptr;
} SifFile;

Examples

Reading Image Data

SifFile sif_file;
if (sif_open_file("spectrum.sif", &sif_file) == 0) {
 printf("Image size: %dx%d, Frames: %d\n", 
 sif_file.info.image_width, 
 sif_file.info.image_height,
 sif_file.info.number_of_frames);
 
 // Load all frames
 if (sif_load_all_frames(&sif_file, 0) == 0) {
 float* frame0 = sif_get_frame_data(&sif_file, 0);
 
 // Process frame data
 for (int i = 0; i < 10; i++) {
 printf("Pixel %d: %.1f\n", i, frame0[i]);
 }
 }
 
 sif_close(&sif_file);
}

JSON Output (C)

SifFile sif_file;
if (sif_open_file("spectrum.sif", &sif_file) == 0) {
 JsonOutputOptions opts = {
 .pretty_print = 1,
 .include_metadata = 1,
 .include_calibration = 1,
 .include_raw_data = 1
 };
 
 char* json_str = sif_file_to_json(&sif_file, opts);
 if (json_str) {
 printf("JSON Output:\n%s\n", json_str);
 free(json_str);
 }
 
 sif_close(&sif_file);
}

Node.js Integration

const sifParser = require('./build/Release/sifaddon.node');
class SpectrumAnalyzer {
 static parseFile(filename) {
 try {
 const jsonString = sifParser.sifFileToJson(filename);
 const data = JSON.parse(jsonString);
 
 return {
 intensities: data.data,
 wavelengths: this.calculateWavelengths(data),
 metadata: data.metadata,
 calibration: data.calibration
 };
 } catch (error) {
 throw new Error(`Failed to parse SIF file: ${error.message}`);
 }
 }
 
 static calculateWavelengths(data) {
 if (data.calibration && data.calibration.coefficients) {
 const coeffs = data.calibration.coefficients;
 return data.data.map((_, i) => {
 // Polynomial calibration: λ = c0 + c1*x + c2*x2 + c3*x3
 const x = i;
 return coeffs[0] + coeffs[1]*x + coeffs[2]*x*x + coeffs[3]*x*x*x;
 });
 }
 return null;
 }
}
// Usage
const spectrum = SpectrumAnalyzer.parseFile('spectrum.sif');
console.log('Peak intensity:', Math.max(...spectrum.intensities));
console.log('Data points:', spectrum.intensities.length);

Working with Calibration Data

int calib_size;
double* calibration = retrieve_calibration(&sif_file.info, &calib_size);
if (calibration) {
 printf("Calibration coefficients: %d\n", sif_file.info.calibration_coeff_count);
 
 if (sif_file.info.has_frame_calibrations) {
 printf("Frame-specific calibration available\n");
 } else {
 printf("Global calibration data:\n");
 for (int i = 0; i < 5 && i < calib_size; i++) {
 printf(" [%d] = %f\n", i, calibration[i]);
 }
 }
 
 free(calibration);
}

Javascript Integration by Node Addon

 // crate binary data uinsg Float32Array
 size_t buffer_size = total_data_points * sizeof(float); //every data point occupies a float
 Napi::ArrayBuffer array_buffer = Napi::ArrayBuffer::New(env, buffer_size); //initialize arraybuffer of a continuous memmory of buffer_size in size in JS with Napi
 float* buffer_data = static_cast<float*>(array_buffer.Data()); // claim a pointer pointing towards the initial position of array_buffer (array_buffer.Data() return void* so it needs static_cast to float pointer)
 // direct copy
 memcpy(buffer_data, sif_file.frame_data, buffer_size);
 // create Float32Array
 Napi::TypedArray binary_data = Napi::TypedArrayOf<float>::New(env, 
 total_data_points, array_buffer, 0, napi_float32_array);
...

ArrayBuffer (10,240,000 bytes = 2,560,000 ×ばつ 4)
┌──────────────────────────────────────────────────────────────────────┐
│ bytes 0-3 │ bytes 4-7 │ bytes 8-11 │ ... │ bytes 10239996-10239999 │
│ float[0] │ float[1] │ float[2] │ ... │ float[2559999] │
└──────────────────────────────────────────────────────────────────────┘
 ↑ ↑ ↑ ↑
Float32Array view (2,560,000 elements)
┌──────────────┬──────────────┬──────────────┬───┬─────────────────────┐
│ element[0] │ element[1] │ element[2] │...│ element[2559999] │
└──────────────┴──────────────┴──────────────┴───┴─────────────────────┘

Compile with N-API

sudo npm install -g node-gyp

#if there is 'build' by CMakeLists
mv build build_cmake_backup
mkdir build
npx node-gyp configure
npx node-gyp build

rm -rf build
npx node-gyp clean
npx node-gyp configure
npx node-gyp build

Load the node addon

Debug Tools

debug_detail_sif

debug_sif

Installation

System-wide Installation

cd build
sudo make install

Using in Your Project

CMake Integration

# CMakeLists.txt
find_library(SIFPARSER_LIB sifparser)
target_link_libraries(your_target ${SIFPARSER_LIB})

Node.js Integration

# Install from local path
npm install /path/to/csif
# Or link for development
cd /path/to/csif
npm link
cd /path/to/your-project
npm link sif-parser

Performance Comparison

License

Contributing

Development

# C library development
mkdir build && cd build
cmake -DCMAKE_BUILD_TYPE=Debug ..
make
# Node.js addon development
npm run clean && npm run build
# Testing
npm test
./bin/read_sif test_data/example.sif

Project Architecture

Citation

@software{csif_parser,
 title = {csif: Andor SIF Parser in C},
 author = {Tim},
 year = {2025},
 url = {https://github.com/mithgil/csif}
}

Support