int imFileFormatJPEG::WriteImageData(void* data) { if (setjmp(this->jerr.setjmp_buffer)) return IM_ERR_ACCESS; imCounterTotal(this->counter, this->dinfo.output_height, "Writing JPEG..."); int row = 0, plane = 0; while (this->cinfo.next_scanline < this->cinfo.image_height) { imFileLineBufferWrite(this, data, row, plane); if (jpeg_write_scanlines(&this->cinfo, (JSAMPARRAY)&this->line_buffer, 1) == 0) return IM_ERR_ACCESS; if (!imCounterInc(this->counter)) { jpeg_finish_compress(&this->cinfo); return IM_ERR_COUNTER; } imFileLineBufferInc(this, &row, &plane); } jpeg_finish_compress(&this->cinfo); return IM_ERR_NONE; }
int imFileFormatLED::WriteImageData(void* data) { imCounterTotal(this->counter, this->height, "Writing LED..."); for (int row = 0; row < this->height; row++) { imFileLineBufferWrite(this, data, row, 0); for (int col = 0; col < this->width; col++) { if (!imBinFilePrintf(handle, ",%d", (int)((imbyte*)this->line_buffer)[col])) return IM_ERR_ACCESS; } imBinFileWrite(handle, (void*)"\n", 1, 1); if (imBinFileError(handle)) return IM_ERR_ACCESS; if (!imCounterInc(this->counter)) return IM_ERR_COUNTER; } imBinFileWrite(handle, (void*)")", 1, 1); if (imBinFileError(handle)) return IM_ERR_ACCESS; return IM_ERR_NONE; }
int imFileFormatJPEG::ReadImageData(void* data) { if (setjmp(this->jerr.setjmp_buffer)) return IM_ERR_ACCESS; imCounterTotal(this->counter, this->dinfo.output_height, "Reading JPEG..."); int row = 0, plane = 0; while (this->dinfo.output_scanline < this->dinfo.output_height) { if (jpeg_read_scanlines(&this->dinfo, (JSAMPARRAY)&this->line_buffer, 1) == 0) return IM_ERR_ACCESS; if (this->fix_adobe_cmyk) iFixAdobeCMYK((unsigned char*)this->line_buffer, this->width); imFileLineBufferRead(this, data, row, plane); if (!imCounterInc(this->counter)) { jpeg_finish_decompress(&this->dinfo); return IM_ERR_COUNTER; } imFileLineBufferInc(this, &row, &plane); } jpeg_finish_decompress(&this->dinfo); return IM_ERR_NONE; }
int imFileFormatRAS::WriteImageData(void* data) { imCounterTotal(this->counter, this->height, "Writing RAS..."); imbyte* compressed_buffer = NULL; if (this->comp_type == RAS_BYTE_ENCODED) // point to the extra buffer compressed_buffer = (imbyte*)this->line_buffer + this->line_buffer_size+2; for (int row = 0; row < this->height; row++) { imFileLineBufferWrite(this, data, row, 0); if (this->bpp > 8) FixRGB(); if (this->comp_type == RAS_BYTE_ENCODED) { int compressed_size = iRASEncodeScanLine(compressed_buffer, (imbyte*)this->line_buffer, this->line_raw_size); imBinFileWrite(handle, compressed_buffer, compressed_size, 1); } else { imBinFileWrite(handle, this->line_buffer, this->line_raw_size, 1); } if (imBinFileError(handle)) return IM_ERR_ACCESS; if (!imCounterInc(this->counter)) return IM_ERR_COUNTER; } return IM_ERR_NONE; }
int imFileFormatRAS::ReadImageData(void* data) { imCounterTotal(this->counter, this->height, "Reading RAS..."); for (int row = 0; row < this->height; row++) { /* read and decompress the data */ if (this->comp_type != RAS_BYTE_ENCODED) { imBinFileRead(handle, this->line_buffer, this->line_raw_size, 1); if (imBinFileError(handle)) return IM_ERR_ACCESS; } else { if (iRASDecodeScanLine(handle, (imbyte*)this->line_buffer, this->line_raw_size) == IM_ERR_ACCESS) return IM_ERR_ACCESS; } if (this->bpp > 8) FixRGB(); imFileLineBufferRead(this, data, row, 0); if (!imCounterInc(this->counter)) return IM_ERR_COUNTER; } return IM_ERR_NONE; }
int imFileFormatJP2::WriteImageData(void* data) { int count = imFileLineBufferCount(this); imCounterTotal(this->counter, count, "Writing JP2..."); /* first time count */ int depth = imColorModeDepth(this->file_color_mode); if (imColorModeHasAlpha(this->user_color_mode) && imColorModeHasAlpha(this->file_color_mode)) { jas_image_setcmpttype(image, depth-1, JAS_IMAGE_CT_OPACITY); depth--; } for (int d = 0; d < depth; d++) jas_image_setcmpttype(image, d, JAS_IMAGE_CT_COLOR(d)); int row = 0, plane = 0; for (int i = 0; i < count; i++) { imFileLineBufferWrite(this, data, row, plane); int ret = 1; if (this->file_data_type == IM_BYTE) ret = iJP2WriteLine(image, row, plane, (imbyte*)this->line_buffer); else ret = iJP2WriteLine(image, row, plane, (imushort*)this->line_buffer); if (!ret) return IM_ERR_ACCESS; if (!imCounterInc(this->counter)) return IM_ERR_COUNTER; imFileLineBufferInc(this, &row, &plane); } char outopts[512] = ""; imAttribTable* attrib_table = AttribTable(); float* ratio = (float*)attrib_table->Get("CompressionRatio"); if (ratio) sprintf(outopts, "rate=%g", (double)(1.0 / *ratio)); // The counter continuous because in Jasper all image writing is done here. BAD! ijp2_counter = this->counter; ijp2_abort = 0; ijp2_message = NULL; /* other counts */ int err = jas_image_encode(image, stream, 0 /*JP2 format always */, outopts); ijp2_counter = -1; if (err) return IM_ERR_ACCESS; jas_stream_flush(stream); return IM_ERR_NONE; }
int imProcessHoughLines(const imImage* src_image, imImage *dst_image) { int counter = imCounterBegin("Hough Line Transform"); imCounterTotal(counter, src_image->height, "Processing..."); int ret = houghLine(src_image, dst_image, counter); imCounterEnd(counter); return ret; }
static void iJP2ProgressProc(int done, int total, char *descr) { (void)descr; if (done == 0) { imCounterTotal(ijp2_counter, total, ijp2_message); ijp2_message = NULL; } if (!imCounterIncTo(ijp2_counter, done)) ijp2_abort = 1; }
int imProcessGrayMorphConvolve(const imImage* src_image, imImage* dst_image, const imImage *kernel, int ismax) { int ret = 0; int counter = imProcessCounterBegin("Gray Morphological Convolution"); const char* msg = (const char*)imImageGetAttribute(kernel, "Description", NULL, NULL); if (!msg) msg = "Processing..."; imCounterTotal(counter, src_image->depth*src_image->height, msg); imImage* fkernel = NULL; if ((src_image->data_type == IM_FLOAT || src_image->data_type == IM_DOUBLE) && kernel->data_type != src_image->data_type) { fkernel = imImageCreate(kernel->width, kernel->height, IM_GRAY, src_image->data_type); imProcessConvertDataType(kernel, fkernel, 0, 0, 0, IM_CAST_DIRECT); kernel = fkernel; } for (int i = 0; i < src_image->depth; i++) { switch(src_image->data_type) { case IM_BYTE: ret = DoGrayMorphConvolve((imbyte*)src_image->data[i], (imbyte*)dst_image->data[i], src_image->width, src_image->height, kernel, counter, ismax, (int)0); break; case IM_SHORT: ret = DoGrayMorphConvolve((short*)src_image->data[i], (short*)dst_image->data[i], src_image->width, src_image->height, kernel, counter, ismax, (int)0); break; case IM_USHORT: ret = DoGrayMorphConvolve((imushort*)src_image->data[i], (imushort*)dst_image->data[i], src_image->width, src_image->height, kernel, counter, ismax, (int)0); break; case IM_INT: ret = DoGrayMorphConvolve((int*)src_image->data[i], (int*)dst_image->data[i], src_image->width, src_image->height, kernel, counter, ismax, (int)0); break; case IM_FLOAT: ret = DoGrayMorphConvolve((float*)src_image->data[i], (float*)dst_image->data[i], src_image->width, src_image->height, kernel, counter, ismax, (float)0); break; case IM_DOUBLE: ret = DoGrayMorphConvolve((double*)src_image->data[i], (double*)dst_image->data[i], src_image->width, src_image->height, kernel, counter, ismax, (double)0); break; } if (!ret) break; } if (fkernel) imImageDestroy(fkernel); imProcessCounterEnd(counter); return ret; }
int imFileFormatSGI::WriteImageData(void* data) { int count = imFileLineBufferCount(this); imCounterTotal(this->counter, count, "Writing SGI..."); imbyte* compressed_buffer = NULL; if (this->comp_type == SGI_RLE) // point to the extra buffer compressed_buffer = (imbyte*)this->line_buffer + this->line_buffer_size; int row = 0, plane = 0; for (int i = 0; i < count; i++) { imFileLineBufferWrite(this, data, row, plane); if (this->comp_type == SGI_VERBATIM) imBinFileWrite(handle, this->line_buffer, this->line_buffer_size/this->bpc, this->bpc); else { int length; if (this->bpc == 1) length = iSGIEncodeScanLine(compressed_buffer, (imbyte*)this->line_buffer, this->width); else length = iSGIEncodeScanLine((imushort*)compressed_buffer, (imushort*)this->line_buffer, this->width); int row_index = row + plane*this->height; this->starttab[row_index] = imBinFileTell(handle); this->lengthtab[row_index] = length*this->bpc; imBinFileWrite(handle, compressed_buffer, length, this->bpc); } if (imBinFileError(handle)) return IM_ERR_ACCESS; if (!imCounterInc(this->counter)) return IM_ERR_COUNTER; imFileLineBufferInc(this, &row, &plane); } if (this->comp_type == SGI_RLE) { imBinFileSeekTo(this->handle, 512); int tablen = this->height * imColorModeDepth(this->file_color_mode); imBinFileWrite(handle, this->starttab, tablen, 4); imBinFileWrite(handle, this->lengthtab, tablen, 4); } return IM_ERR_NONE; }
int imProcessResize(const imImage* src_image, imImage* dst_image, int order) { int ret = 0; int counter = imProcessCounterBegin("Resize"); const char* int_msg = (order == 3)? "Bicubic Interpolation": (order == 1)? "Bilinear Interpolation": "Zero Order Interpolation"; int src_depth = src_image->has_alpha? src_image->depth+1: src_image->depth; imCounterTotal(counter, src_depth*dst_image->height, int_msg); for (int i = 0; i < src_depth; i++) { switch(src_image->data_type) { case IM_BYTE: ret = iResize(src_image->width, src_image->height, (const imbyte*)src_image->data[i], dst_image->width, dst_image->height, (imbyte*)dst_image->data[i], float(0), order, counter); break; case IM_SHORT: ret = iResize(src_image->width, src_image->height, (const short*)src_image->data[i], dst_image->width, dst_image->height, (short*)dst_image->data[i], float(0), order, counter); break; case IM_USHORT: ret = iResize(src_image->width, src_image->height, (const imushort*)src_image->data[i], dst_image->width, dst_image->height, (imushort*)dst_image->data[i], float(0), order, counter); break; case IM_INT: ret = iResize(src_image->width, src_image->height, (const int*)src_image->data[i], dst_image->width, dst_image->height, (int*)dst_image->data[i], float(0), order, counter); break; case IM_FLOAT: ret = iResize(src_image->width, src_image->height, (const float*)src_image->data[i], dst_image->width, dst_image->height, (float*)dst_image->data[i], float(0), order, counter); break; case IM_CFLOAT: ret = iResize(src_image->width, src_image->height, (const imcfloat*)src_image->data[i], dst_image->width, dst_image->height, (imcfloat*)dst_image->data[i], imcfloat(0,0), order, counter); break; } } imProcessCounterEnd(counter); return ret; }
int imFileFormatSGI::ReadImageData(void* data) { int count = imFileLineBufferCount(this); imCounterTotal(this->counter, count, "Reading SGI..."); imbyte* compressed_buffer = NULL; if (this->comp_type == SGI_RLE) // point to the extra buffer compressed_buffer = (imbyte*)this->line_buffer + this->line_buffer_size; int row = 0, plane = 0; for (int i = 0; i < count; i++) { if (this->comp_type == SGI_VERBATIM) { imBinFileRead(handle, this->line_buffer, this->line_buffer_size/this->bpc, this->bpc); if (imBinFileError(handle)) return IM_ERR_ACCESS; } else { int row_index = row + plane*this->height; imBinFileSeekTo(handle, this->starttab[row_index]); imBinFileRead(handle, compressed_buffer, this->lengthtab[row_index] / this->bpc, this->bpc); if (imBinFileError(handle)) return IM_ERR_ACCESS; if (this->bpc == 1) iSGIDecodeScanLine((imbyte*)this->line_buffer, compressed_buffer, this->width); else iSGIDecodeScanLine((imushort*)this->line_buffer, (imushort*)compressed_buffer, this->width); } imFileLineBufferRead(this, data, row, plane); if (!imCounterInc(this->counter)) return IM_ERR_COUNTER; imFileLineBufferInc(this, &row, &plane); } return IM_ERR_NONE; }
int imProcessRotateRef(const imImage* src_image, imImage* dst_image, double cos0, double sin0, int x, int y, int to_origin, int order) { int ret = 0; int counter = imCounterBegin("RotateRef"); int src_depth = src_image->has_alpha? src_image->depth+1: src_image->depth; imCounterTotal(counter, src_depth*dst_image->height, "Processing..."); /* size of the destiny image */ if (src_image->color_space == IM_MAP) { ret = Rotate(src_image->width, src_image->height, (imbyte*)src_image->data[0], dst_image->width, dst_image->height, (imbyte*)dst_image->data[0], cos0, sin0, x, y, to_origin, counter, float(0), 0); } else { for (int i = 0; i < src_depth; i++) { switch(src_image->data_type) { case IM_BYTE: ret = Rotate(src_image->width, src_image->height, (imbyte*)src_image->data[i], dst_image->width, dst_image->height, (imbyte*)dst_image->data[i], cos0, sin0, x, y, to_origin, counter, float(0), order); break; case IM_USHORT: ret = Rotate(src_image->width, src_image->height, (imushort*)src_image->data[i], dst_image->width, dst_image->height, (imushort*)dst_image->data[i], cos0, sin0, x, y, to_origin, counter, float(0), order); break; case IM_INT: ret = Rotate(src_image->width, src_image->height, (int*)src_image->data[i], dst_image->width, dst_image->height, (int*)dst_image->data[i], cos0, sin0, x, y, to_origin, counter, float(0), order); break; case IM_FLOAT: ret = Rotate(src_image->width, src_image->height, (float*)src_image->data[i], dst_image->width, dst_image->height, (float*)dst_image->data[i], cos0, sin0, x, y, to_origin, counter, float(0), order); break; case IM_CFLOAT: ret = Rotate(src_image->width, src_image->height, (imcfloat*)src_image->data[i], dst_image->width, dst_image->height, (imcfloat*)dst_image->data[i], cos0, sin0, x, y, to_origin, counter, imcfloat(0,0), order); break; } if (!ret) break; } } imCounterEnd(counter); return ret; }
int imFileFormatJP2::ReadImageData(void* data) { int count = imFileLineBufferCount(this); imCounterTotal(this->counter, count, NULL); int alpha_plane = -1; if (imColorModeHasAlpha(this->user_color_mode) && imColorModeHasAlpha(this->file_color_mode)) alpha_plane = imColorModeDepth(this->file_color_mode) - 1; int row = 0, plane = 0; for (int i = 0; i < count; i++) { int cmpno; if (plane == alpha_plane) cmpno = jas_image_getcmptbytype(image, JAS_IMAGE_CT_OPACITY); else cmpno = jas_image_getcmptbytype(image, JAS_IMAGE_CT_COLOR(plane)); if (cmpno == -1) return IM_ERR_DATA; int ret = 1; if (this->file_data_type == IM_BYTE) ret = iJP2ReadLine(image, row, cmpno, (imbyte*)this->line_buffer); else ret = iJP2ReadLine(image, row, cmpno, (imushort*)this->line_buffer); if (!ret) return IM_ERR_ACCESS; imFileLineBufferRead(this, data, row, plane); if (!imCounterInc(this->counter)) return IM_ERR_COUNTER; imFileLineBufferInc(this, &row, &plane); } return IM_ERR_NONE; }
int imFileFormatPFM::WriteImageData(void* data) { imCounterTotal(this->counter, this->height, "Writing PFM..."); int line_raw_size = imImageLineSize(this->width, this->file_color_mode, this->file_data_type); for (int row = 0; row < this->height; row++) { imFileLineBufferWrite(this, data, row, 0); imBinFileWrite(handle, this->line_buffer, line_raw_size, 1); if (imBinFileError(handle)) return IM_ERR_ACCESS; if (!imCounterInc(this->counter)) return IM_ERR_COUNTER; } return IM_ERR_NONE; }
int imProcessRenderCondOp(imImage* image, imRenderCondFunc render_func, const char* render_name, float* param) { int ret = 0; int counter = imProcessCounterBegin(render_name); imCounterTotal(counter, image->depth*image->height, "Rendering..."); for (int d = 0; d < image->depth; d++) { switch(image->data_type) { case IM_BYTE: ret = DoRenderCondOp((imbyte*)image->data[d], image->width, image->height, d, render_func, param, counter); break; case IM_SHORT: ret = DoRenderCondOp((short*)image->data[d], image->width, image->height, d, render_func, param, counter); break; case IM_USHORT: ret = DoRenderCondOp((imushort*)image->data[d], image->width, image->height, d, render_func, param, counter); break; case IM_INT: ret = DoRenderCondOp((int*)image->data[d], image->width, image->height, d, render_func, param, counter); break; case IM_FLOAT: ret = DoRenderCondOp((float*)image->data[d], image->width, image->height, d, render_func, param, counter); break; case IM_DOUBLE: ret = DoRenderCondOp((double*)image->data[d], image->width, image->height, d, render_func, param, counter); break; } if (!ret) break; } imProcessCounterEnd(counter); return ret; }
int imProcessSwirl(const imImage* src_image, imImage* dst_image, float k, int order) { int ret = 0; int counter = imCounterBegin("Swirl Distort"); int src_depth = src_image->has_alpha? src_image->depth+1: src_image->depth; imCounterTotal(counter, src_depth*dst_image->height, "Processing..."); /* size of the destiny image */ for (int i = 0; i < src_depth; i++) { switch(src_image->data_type) { case IM_BYTE: ret = Swirl(src_image->width, src_image->height, (imbyte*)src_image->data[i], (imbyte*)dst_image->data[i], k, counter, float(0), order); break; case IM_USHORT: ret = Swirl(src_image->width, src_image->height, (imushort*)src_image->data[i], (imushort*)dst_image->data[i], k, counter, float(0), order); break; case IM_INT: ret = Swirl(src_image->width, src_image->height, (int*)src_image->data[i], (int*)dst_image->data[i], k, counter, float(0), order); break; case IM_FLOAT: ret = Swirl(src_image->width, src_image->height, (float*)src_image->data[i], (float*)dst_image->data[i], k, counter, float(0), order); break; case IM_CFLOAT: ret = Swirl(src_image->width, src_image->height, (imcfloat*)src_image->data[i], (imcfloat*)dst_image->data[i], k, counter, imcfloat(0,0), order); break; } if (!ret) break; } imCounterEnd(counter); return ret; }
int imFileFormatLED::ReadImageData(void* data) { int value; imCounterTotal(this->counter, this->height, "Reading LED..."); for (int row = 0; row < this->height; row++) { for (int col = 0; col < this->width; col++) { if (!imBinFileReadInteger(handle, &value)) return IM_ERR_ACCESS; ((imbyte*)this->line_buffer)[col] = (unsigned char)value; } imFileLineBufferRead(this, data, row, 0); if (!imCounterInc(this->counter)) return IM_ERR_COUNTER; } return IM_ERR_NONE; }
int imFileFormatECW::ReadImageData(void* data) { imAttribTable* attrib_table = AttribTable(); int i, *attrib_data, view_width, view_height, nBands = imColorModeDepth(this->file_color_mode); // this size is free, can be anything, but we restricted to less than the image size attrib_data = (int*)attrib_table->Get("ViewWidth"); view_width = attrib_data? *attrib_data: this->width; if (view_width > this->width) view_width = this->width; attrib_data = (int*)attrib_table->Get("ViewHeight"); view_height = attrib_data? *attrib_data: this->height; if (view_height > this->height) view_height = this->height; imCounterTotal(this->counter, view_height, "Reading ECW..."); { int xmin, xmax, ymin, ymax, band_start; // full image if not defined. // this size must be inside the image attrib_data = (int*)attrib_table->Get("ViewXmin"); xmin = attrib_data? *attrib_data: 0; if (xmin < 0) xmin = 0; attrib_data = (int*)attrib_table->Get("ViewYmin"); ymin = attrib_data? *attrib_data: 0; if (ymin < 0) ymin = 0; attrib_data = (int*)attrib_table->Get("ViewXmax"); xmax = attrib_data? *attrib_data: this->width-1; if (xmax > this->width-1) xmax = this->width-1; attrib_data = (int*)attrib_table->Get("ViewYmax"); ymax = attrib_data? *attrib_data: this->height-1; if (ymax > this->height-1) ymax = this->height-1; band_start = 0; UINT16* start_plane = (UINT16*)attrib_table->Get("MultiBandSelect"); if (start_plane) band_start = *start_plane; UINT32 *pBandList = (UINT32*)malloc(sizeof(UINT32)*nBands); for(i = 0; i < nBands; i++) pBandList[i] = i+band_start; NCSError eError = NCScbmSetFileView(this->pNCSFileView, nBands, pBandList, xmin, ymin, xmax, ymax, view_width, view_height); free(pBandList); if( eError != NCS_SUCCESS) return IM_ERR_DATA; } // this is necessary to fool line buffer management this->width = view_width; this->height = view_height; this->line_buffer_size = imImageLineSize(this->width, this->file_color_mode, this->file_data_type); NCSEcwCellType eType = NCSCT_UINT8; int type_size = 1; if (this->file_data_type == IM_SHORT) { eType = NCSCT_INT16; type_size = 2; } else if (this->file_data_type == IM_USHORT) { eType = NCSCT_UINT16; type_size = 2; } else if (this->file_data_type == IM_FLOAT) { eType = NCSCT_IEEE4; type_size = 4; } UINT8 **ppOutputLine = (UINT8**)malloc(sizeof(UINT8*)*nBands); UINT8 *ppOutputBuffer = (UINT8*)malloc(type_size*view_width*nBands); for(i = 0; i < nBands; i++) ppOutputLine[i] = ppOutputBuffer + i*type_size*view_width; for (int row = 0; row < view_height; row++) { NCSEcwReadStatus eError = NCScbmReadViewLineBILEx(this->pNCSFileView, eType, (void**)ppOutputLine); if( eError != NCS_SUCCESS) { free(ppOutputLine); free(ppOutputBuffer); return IM_ERR_DATA; } iCopyDataBuffer(ppOutputLine, (imbyte*)this->line_buffer, nBands, view_width, type_size); imFileLineBufferRead(this, data, row, 0); if (!imCounterInc(this->counter)) { free(ppOutputLine); free(ppOutputBuffer); return IM_ERR_COUNTER; } } free(ppOutputLine); free(ppOutputBuffer); return IM_ERR_NONE; }
int imFileFormatRAW::ReadImageData(void* data) { int count = imFileLineBufferCount(this); int line_count = imImageLineCount(this->width, this->file_color_mode); int type_size = iFileDataTypeSize(this->file_data_type, this->switch_type); // treat complex as 2 real if (this->file_data_type == IM_CFLOAT) { type_size /= 2; line_count *= 2; } int ascii; if (imStrEqual(this->compression, "ASCII")) ascii = 1; else ascii = 0; imCounterTotal(this->counter, count, "Reading RAW..."); int row = 0, plane = 0; for (int i = 0; i < count; i++) { if (ascii) { for (int col = 0; col < line_count; col++) { if (this->file_data_type == IM_FLOAT) { float value; if (!imBinFileReadFloat(handle, &value)) return IM_ERR_ACCESS; ((float*)this->line_buffer)[col] = value; } else { int value; if (!imBinFileReadInteger(handle, &value)) return IM_ERR_ACCESS; if (this->file_data_type == IM_INT) ((int*)this->line_buffer)[col] = value; else if (this->file_data_type == IM_SHORT) ((short*)this->line_buffer)[col] = (short)value; else if (this->file_data_type == IM_USHORT) ((imushort*)this->line_buffer)[col] = (imushort)value; else ((imbyte*)this->line_buffer)[col] = (unsigned char)value; } } } else { imBinFileRead(this->handle, (imbyte*)this->line_buffer, line_count, type_size); if (imBinFileError(this->handle)) return IM_ERR_ACCESS; } imFileLineBufferRead(this, data, row, plane); if (!imCounterInc(this->counter)) return IM_ERR_COUNTER; imFileLineBufferInc(this, &row, &plane); if (this->padding) imBinFileSeekOffset(this->handle, this->padding); } return IM_ERR_NONE; }
int imFileFormatRAW::WriteImageData(void* data) { int count = imFileLineBufferCount(this); int line_count = imImageLineCount(this->width, this->file_color_mode); int type_size = iFileDataTypeSize(this->file_data_type, this->switch_type); // treat complex as 2 real if (this->file_data_type == IM_CFLOAT) { type_size /= 2; line_count *= 2; } int ascii; if (imStrEqual(this->compression, "ASCII")) ascii = 1; else ascii = 0; imCounterTotal(this->counter, count, "Writing RAW..."); int row = 0, plane = 0; for (int i = 0; i < count; i++) { imFileLineBufferWrite(this, data, row, plane); if (ascii) { for (int col = 0; col < line_count; col++) { if (this->file_data_type == IM_FLOAT) { float value = ((float*)this->line_buffer)[col]; if (!imBinFilePrintf(handle, "%f ", (double)value)) return IM_ERR_ACCESS; } else { int value; if (this->file_data_type == IM_INT) value = ((int*)this->line_buffer)[col]; else if (this->file_data_type == IM_SHORT) value = ((short*)this->line_buffer)[col]; else if (this->file_data_type == IM_USHORT) value = ((imushort*)this->line_buffer)[col]; else value = ((imbyte*)this->line_buffer)[col]; if (!imBinFilePrintf(handle, "%d ", value)) return IM_ERR_ACCESS; } } imBinFileWrite(handle, (void*)"\n", 1, 1); } else { imBinFileWrite(this->handle, (imbyte*)this->line_buffer, line_count, type_size); } if (imBinFileError(this->handle)) return IM_ERR_ACCESS; if (!imCounterInc(this->counter)) return IM_ERR_COUNTER; imFileLineBufferInc(this, &row, &plane); if (this->padding) imBinFileSeekOffset(this->handle, this->padding); } this->image_count++; return IM_ERR_NONE; }