буфер для приёма изображения, c камеры FLI Опции

[MarYuriy]

Здравствуйте!

Появилась задача написания небольшой програмы для работы с камерами FLI с помощью их SDK (flicamera.com).

Вопрос такой: как правильно отписывать в буфер ряды(rows) с камеры, чтобы они накапливались непосредственно в буфере, а потом отписывались все вместе в файл, а не по-одному из буфера в файл, как это сделано у меня?

Конкретно в реализации приёма рядов у меня появилось несколько проблем:

Проблема 1-ая заключается в том, что, увеличивая буфер до разрешения изображения 4000x2700 пикселей, компилятор компилирует файл, а вот, когда запускаешь exe-файл, вылетает ошибка Windows, ряды не принимаются, файл не создаётся.
Проблема 2-ая: при отписывании рядов, в конце каждого ряда появляются какие-то одинаковые значения (проверил с помощью засветки кадра, когда все значения равны FF FF).
Проблема 3-я: создаваемый файл должен весить около 20 мб (при моих настройках), но, по какой-то причине он периодически в 10 раз меньше. Это, вообще, не укладывается в голове.

Ряды отписываются с помощью ф-ции FLIGrabRow():
LIBFLIAPI FLIGrabRow (flidev t dev, void* buff, size t width)
Grab a row of an image. This function grabs the next available row of the image from camera device dev. The row of width width is placed in the buffer pointed to by buff. The size of the buffer pointed to by buff must take into account the bit depth of the image, meaning the buffer size must be at least width bytes for an 8-bit image, and at least 2*width for a 16-bit image.
Return Value: Zero on success.
Non-zero on failure.
Parameters:
dev: Camera whose image to grab the next available row from.
buff: Pointer to where the next available row will be placed.
width: Row width in pixels.
Полная документация здесь:
http://flicamera.com/downloads/FLI_SDK_Documentation.pdf

Используемый компилятор:wxDev-C++ 7.3.1.3.

Проблемная часть кода:

CODE

long img_size;

char strII[row_width*2]; //row_width*rows;
char *intarray = strII;

//intarray=(char*)malloc(4080*sizeof(char));

// if((malloc(img_size)) == NULL) printf("malloc() failed");
// else printf("malloc() good\n\n");

img_size = rows * row_width*sizeof(char);
printf("img_size -->> %d%\n\n", img_size);

FILE *pf;

// Приём изображения
int row = 0;
int portion = 0;
for (row = 0; row < rows; row++)
{
x = FLIGrabRow (dev, intarray, row_width);

pf=fopen("data","ab");
fprintf(pf,"%s\n",intarray);
fclose(pf);

fflush(pf);
}
// free (intarray);

Весь код:

CODE

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include "libfli.h"

#pragma comment(lib,"E:\projects\c_projects\43_FLI_2\libfli.lib")

#define BUFFSIZE 10000

int x,y,z;

int main(int argc, char *argv[])
{
flidev_t dev;
flidomain_t domain;
domain = (FLIDOMAIN_USB | FLIDEVICE_CAMERA);
char str[]="flipro0";
char *m =str; // FLIOpen
y = FLIOpen(&dev, m, domain); // Начать работу с устройством
//----------------------------------------------------------------------------
long hwrev, fwrev;

FLIGetHWRevision (dev, &hwrev); // FLIGetHWRevision
FLIGetFWRevision (dev, &fwrev); // FLIGetFWRevision

printf("FLIGet(F)HWRevision: fwrev:%d, hwrev: %d\n\n", fwrev, hwrev);
//----------------------------------------------------------------------------
long ul_x, ul_y, lr_x, lr_y, row_width, rows;

FLIGetArrayArea (dev, &ul_x, &ul_y, &lr_x, &lr_y); // FLIGetArrayArea
row_width = lr_x - ul_x;
rows = lr_y - ul_y;
printf("FLIGetArrayArea: %d;%d;%d;%d; rows: %d row_width: %d\n\n", ul_x, ul_y,
lr_x, lr_y, rows, row_width);
//----------------------------------------------------------------------------
FLIGetVisibleArea (dev, &ul_x, &ul_y, &lr_x, &lr_y); // FLIGetVisibleArea

row_width = lr_x - ul_x;
rows = lr_y - ul_y;

printf("FLIGetVisibleArea: %d;%d;%d;%d; rows: %d row_width: %d\n\n", ul_x, ul_y,
lr_x, lr_y, rows, row_width);
//----------------------------------------------------------------------------
double pixelX, pixelY;

FLIGetPixelSize (dev, &pixelX, &pixelY); // FLIGetPixelSize
printf("FLIGetPixelSize: pixelX: %f pixelY: %f\n\n", pixelX, pixelY);
//----------------------------------------------------------------------------
double temperature;

FLIGetTemperature (dev, &temperature); // FLIGetTemperature
printf("FLIGetTemperature: %f;\n\n",temperature);
//----------------------------------------------------------------------------
char vr[50];
char *ver = vr;

size_t col = 50;
FLIGetLibVersion( vr, col); // FLIGetLibVersion
printf("FLIGetLibVersion: %s;\n\n", ver);
//----------------------------------------------------------------------------
size_t len;
char model[20];
char *mod = model;

FLIGetModel(dev, mod, 20); // FLIGetModel
printf("FLIGetModel: %s;\n\n",mod);
//----------------------------------------------------------------------------
flidebug_t level;
level = FLIDEBUG_NONE;
char ht[20];
char *host = ht;

FLISetDebugLevel (host, level); // FLISetDebugLevel

printf("FLISetDebugLevel: %s;\n\n",host);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
FLISetVBin (dev, 1); // FLISetVBin
FLISetHBin (dev, 1); // FLISetVBin
//----------------------------------------------------------------------------
FLISetImageArea (dev, ul_x, ul_y, lr_x, lr_y); // FLISetImageArea
//----------------------------------------------------------------------------
fliframe_t frametype;
frametype = FLI_FRAME_TYPE_NORMAL; // FLI_FRAME_TYPE_DARK;
FLISetFrameType (dev, frametype); // FLISetFrameType
//----------------------------------------------------------------------------
long exptime = 1000; //msec
FLISetExposureTime (dev, exptime); // FLISetExposureTime
//----------------------------------------------------------------------------
double temperatureToCCD = 0.0;
FLISetTemperature (dev, temperatureToCCD); // FLISetTemperature
//----------------------------------------------------------------------------
flibitdepth_t bitdepth;
bitdepth = FLI_MODE_16BIT; //FLI_MODE_8BIT
FLISetBitDepth (dev, bitdepth); // FLISetBitDepth
//----------------------------------------------------------------------------
long nflushes = 16; // îò 0 äî 16
FLISetNFlushes (dev, nflushes);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//startExposure

FLIExposeFrame (dev);
//----------------------------------------------------------------------------
//FLICancelExposure (dev);
Sleep(exptime+1000);
//----------------------------------------------------------------------------
flishutter_t shutter;
shutter = FLI_SHUTTER_OPEN; // (FLI_SHUTTER_EXTERNAL_TRIGGER_LOW|FLI_SHUTTER_OPEN)
// FLI_SHUTTER_EXTERNAL_TRIGGER_HIGH
// z = FLIControlShutter (dev, shutter);
// Sleep(2000);
//----------------------------------------------------------------------------
shutter = FLI_SHUTTER_CLOSE;
// z = FLIControlShutter (dev, shutter);
//----------------------------------------------------------------------------
long img_size;

char strII[row_width*2];
char *intarray = strII;

//intarray=(char*)malloc(4080*sizeof(char));

// if((malloc(img_size)) == NULL) printf("malloc() failed");
// else printf("malloc() good\n\n");

img_size = rows * row_width*sizeof(char);
printf("img_size -->> %d%\n\n", img_size);

FILE *pf;

// Приём изображения
int row = 0;
int portion = 0;
for (row = 0; row < rows; row++)
{
x = FLIGrabRow (dev, intarray, row_width);

pf=fopen("data","ab");
fprintf(pf,"%s\n",intarray);
fclose(pf);

fflush(pf);
}
// free (intarray);

//----------------------------------------------------------------------------
printf("FLIGrabRow = %d;\nFLIOpen = %d;\nFLIControlShutter = %d;\n\n",x,y,z);
//----------------------------------------------------------------------------
FLIFlushRow (dev, rows, 16); // очистка рядов
//----------------------------------------------------------------------------
FLIClose(dev); // закончить работу с устройством
//----------------------------------------------------------------------------
system("PAUSE");
return 0;
}

[MarYuriy]

Попробовал такой код на работоспособность в разных компиляторах:

#include <cstdlib>
#include <iostream>
using namespace std;

int main(int argc, char *argv[])
{
int rows, row_width;
rows = 2672;
row_width = 4008;
char strII[2672*4008*2];
printf("size %d\n",sizeof(strII));
system("PAUSE");
return EXIT_SUCCESS;
}

Мой wx-Dev С++ компилирует, как я уже говорил, но при выполнении программы, Windows выдаёт ошибку не доходя до
printf("size %d\n",sizeof(strII));

Интересно, что онлайн компилятор http://ideone.com/ компилирует и возвращаемое значение равно:
size 21418752,
а вот http://liveworkspace.org/ и http://codepad.org/ тоже выдают ошибки.

Это, значит, что проблемы в компиляторе?

пс Жаль, что никто не ответил, я думал - вопрос простой...

[andrewlekar]

Попробуйте эту память выделять динамически, через malloc или new.

[_Pasha]

Проблема 2-ая: при отписывании рядов, в конце каждого ряда появляются какие-то одинаковые значения (проверил с помощью засветки кадра, когда все значения равны FF FF).

Это в поток встроена синхра, один из разделителей: нач./конец строки и кадра.

[MarYuriy]

Попробуйте эту память выделять динамически, через malloc или new.

Спасибо за наводку. Вот, что получилось:

CODE

unsigned int *intarray;
intarray=(unsigned int*)malloc(row_width*rows*2*sizeof(unsigned int));//4008*2672*2

if((malloc(*intarray)) == NULL) printf("malloc() failed");
else printf("malloc() good\n\n");

Вроде бы буфер работает. Понял, что надо пользоваться функцией fwrite(), получилось так:

CODE

FILE *pf;
pf=fopen("data","wb");

printf("Read image: ");
int row = 0;
for (row = 0; row < rows; row++)
{
x = FLIGrabRow (dev, &intarray, row_width);
fflush(stdout);
fwrite(intarray,sizeof(unsigned int),row_width,pf);
}
fclose(pf);
free (intarray);

Насколько это правильно?

[MarYuriy]

Если это кому-то ещё интересно. Наконец-то разобрался, как получить всё изображение в бинарном виде и записать в файл.

CODE

unsigned short *intarray; //= strII;
intarray=(unsigned short*)malloc(row_width*rows*2*sizeof(unsigned short));//4008*2672*2

if((malloc(*intarray)) == NULL) printf("malloc() failed");
else printf("malloc() good\n\n");

FILE *pf;
pf=fopen("data","ab");

int row = 0;
for (row = 0; row < rows; row++)
{
x = FLIGrabRow (dev, &intarray[row*row_width], row_width); /
fflush(stdout);
}
fwrite(&intarray[0], sizeof(unsigned short), rows*row_width,pf);
fclose(pf);
free (intarray);

Но вчера нашёл статью Емельянова Э.В. (http://eddy-em.livejournal.com/5087.html), в которой всё доходчиво рассказывается и показывается, что надо делать. А так же говорится о том, что существует стандартная библиотека для работы с FLI-камерами - cfitsio.

В общем, решение нашлось.

Сообщение отредактировал MarYuriy - Jan 13 2013, 15:06