void mitk::CylindricToCartesianFilter::buildConeCutOffShortCut(int orig_xsize, int orig_ysize, mitkIpPicDescriptor *rt_pic, mitkIpPicDescriptor *fr_pic, float a, float b, mitkIpPicDescriptor * &coneCutOff_pic) { coneCutOff_pic=mitkIpPicNew(); coneCutOff_pic->type=mitkIpPicInt; coneCutOff_pic->bpe=16; coneCutOff_pic->dim=2; coneCutOff_pic->n[0]=coneCutOff_pic->n[1]=rt_pic->n[0]; coneCutOff_pic->data=malloc(_mitkIpPicSize(coneCutOff_pic)); int i, size=_mitkIpPicElements(rt_pic); mitkIpInt2_t *rt, *ccop, ohx_size, nz_size; mitkIpFloat4_t *fr; a*=(float)rt_pic->n[0]/orig_xsize; b*=(float)rt_pic->n[0]/orig_xsize; ohx_size=orig_xsize/2; nz_size=orig_ysize*rt_pic->n[0]/orig_xsize; rt=(mitkIpInt2_t *)rt_pic->data; fr=(mitkIpFloat4_t*)fr_pic->data; ccop=(mitkIpInt2_t *)coneCutOff_pic->data; for(i=0; i<size; ++i, ++rt, ++ccop) { register mitkIpInt2_t cco; if(*rt<=ohx_size) cco=(mitkIpInt2_t)(a*(*rt+*fr)+b); else cco=(mitkIpInt2_t)(a*(orig_xsize-(*rt+*fr))+b); if(cco<0) cco=0; if(cco>=nz_size) cco=nz_size; *ccop=cco; } }
mitkIpPicDescriptor *mitkIpFuncRank ( mitkIpPicDescriptor *pic_old, mitkIpUInt4_t rank, mitkIpUInt4_t mask_dim, mitkIpUInt4_t mask_size, mitkIpFuncFlagI_t border ) { mitkIpPicDescriptor *pic_new; /* pointer to transformed image */ mitkIpInt4_t i; /* loop index */ mitkIpInt4_t offset; /* offset of image */ mitkIpInt4_t ind[_mitkIpPicNDIM]; /* loop index vector */ mitkIpInt4_t *off_vekt; /* pointer to offset vector */ mitkIpInt4_t begin; /* 0.5 * mask_size */ mitkIpUInt4_t size[_mitkIpPicNDIM]; /* */ mitkIpInt4_t n[_mitkIpPicNDIM]; /* size of each dimension */ mitkIpUInt4_t no_elem; /* number of elements in mask */ mitkIpUInt4_t len; /* length of offset vector */ /* calculate number of elements in mask */ no_elem = mask_size; for ( i = 1; i < mask_dim; i++ ) no_elem = no_elem * mask_size; /* check whether data are correct */ if ( _mitkIpFuncError ( pic_old ) != mitkIpFuncOK ) return ( mitkIpFuncERROR ); if ( mask_dim < 1 || mask_dim > pic_old->dim ) { _mitkIpFuncSetErrno ( mitkIpFuncDIMMASC_ERROR ); return ( mitkIpFuncERROR ); } if ( rank > no_elem ) { _mitkIpFuncSetErrno ( mitkIpFuncDATA_ERROR ); return ( mitkIpFuncERROR ); } if ( mask_size % 2 != 1 ) { _mitkIpFuncSetErrno ( mitkIpFuncSIZE_ERROR ); return ( mitkIpFuncERROR ); } /* initialize vectors and variables */ size[0] = 1; for ( i = 1; i < _mitkIpPicNDIM; i++ ) size[i] = size[i-1] * pic_old->n[i-1]; len = 0; begin = mask_size / 2; for ( i = 0; i < mask_dim; i++ ) n[i] = begin + 1; for ( i = mask_dim; i < _mitkIpPicNDIM; i++ ) n[i] = 1 - begin; /* allocate image structure */ if ( border == mitkIpFuncBorderOld ) pic_new = mitkIpPicClone ( pic_old ); else if ( border == mitkIpFuncBorderZero ) { pic_new = mitkIpPicCopyHeader ( pic_old, 0 ); pic_new->data = calloc ( _mitkIpPicElements ( pic_new ), pic_new->bpe/8 ); } else { _mitkIpFuncSetErrno ( mitkIpFuncFLAG_ERROR ); return ( mitkIpFuncERROR ); } if ( pic_new == NULL ) { _mitkIpFuncSetErrno ( mitkIpFuncPICNEW_ERROR ); return ( mitkIpFuncERROR ); } /* allocate offset vector */ off_vekt = malloc ( no_elem * sizeof ( mitkIpUInt4_t ) ); if ( off_vekt == NULL ) { _mitkIpFuncSetErrno ( mitkIpFuncMALLOC_ERROR ); return ( mitkIpFuncERROR ); } /* calculate offset vector */ for ( ind[0] = -begin; ind[0] < n[0]; ind[0]++ ) for ( ind[7] = -begin; ind[7] < n[7]; ind[7]++ ) for ( ind[6] = -begin; ind[6] < n[6]; ind[6]++ ) for ( ind[5] = -begin; ind[5] < n[5]; ind[5]++ ) for ( ind[4] = -begin; ind[4] < n[4]; ind[4]++ ) for ( ind[3] = -begin; ind[3] < n[3]; ind[3]++ ) for ( ind[2] = -begin; ind[2] < n[2]; ind[2]++ ) for ( ind[1] = -begin; ind[1] < n[1]; ind[1]++ ) { offset = 0; for ( i = 0; i < pic_old->dim; i++ ) offset = offset + ind[i] * size[i]; off_vekt[len] = offset; len++; } if ( rank == 0 ) rank = no_elem / 2 + 1; mitkIpPicFORALL_4 ( RANK, pic_old, begin, no_elem, size, rank ); free ( off_vekt ); /* Copy Tags */ mitkIpFuncCopyTags(pic_new, pic_old); return ( pic_new ); }
void mitkIpPicPutSlice( const char *outfile_name, mitkIpPicDescriptor *pic, mitkIpUInt4_t slice ) { mitkIpPicDescriptor *pic_in; FILE *outfile; size_t ignored; pic_in = mitkIpPicGetHeader( outfile_name, NULL ); if( pic_in == NULL ) { if( slice == 1 ) { mitkIpBool_t compression; pic->n[pic->dim] = 1; pic->dim += 1; compression = mitkIpPicSetWriteCompression( mitkIpFalse ); mitkIpPicPut( outfile_name, pic ); mitkIpPicSetWriteCompression( compression ); pic->dim -= 1; pic->n[pic->dim] = 0; return; } else return; } pic_in = mitkIpPicGetTags( outfile_name, pic_in ); outfile = fopen( outfile_name, "r+b" ); if( outfile == NULL ) { /*ipPrintErr( "mitkIpPicPut: sorry, error opening outfile\n" );*/ /*return();*/ } if( pic->dim != pic_in->dim - 1 ) { fclose( outfile ); return; } else if( pic->n[0] != pic_in->n[0] ) { fclose( outfile ); return; } else if( pic->n[1] != pic_in->n[1] ) { fclose( outfile ); return; } if( slice > pic_in->n[pic_in->dim-1] ) pic_in->n[pic_in->dim-1] += 1; /* write outfile */ /*fseek( outfile, 0, SEEK_SET );*/ rewind( outfile ); ignored = fwrite( mitkIpPicVERSION, 1, sizeof(mitkIpPicTag_t), outfile ); fseek( outfile, sizeof(mitkIpUInt4_t), SEEK_CUR ); /* skip tags_len */ ignored = mitkIpFWriteLE( &(pic_in->type), sizeof(mitkIpUInt4_t), 1, outfile ); ignored = mitkIpFWriteLE( &(pic_in->bpe), sizeof(mitkIpUInt4_t), 1, outfile ); ignored = mitkIpFWriteLE( &(pic_in->dim), sizeof(mitkIpUInt4_t), 1, outfile ); ignored = mitkIpFWriteLE( pic_in->n, sizeof(mitkIpUInt4_t), pic_in->dim, outfile ); fseek( outfile, pic_in->info->pixel_start_in_file + _mitkIpPicSize(pic) * (slice - 1), SEEK_SET ); ignored = mitkIpFWriteLE( pic->data, pic->bpe / 8, _mitkIpPicElements(pic), outfile ); /*fseek( outfile, 0, SEEK_END );*/ fclose( outfile ); mitkIpPicFree(pic_in); /*return();*/ }
void mitk::ImageDataItem::ConstructVtkImageData() const { vtkImageData *inData = vtkImageData::New(); vtkDataArray *scalars = NULL; unsigned long size = 0; if ( m_PicDescriptor->dim == 1 ) { inData->SetDimensions( m_PicDescriptor->n[0] -1, 1, 1); size = m_PicDescriptor->n[0]; inData->SetOrigin( ((float) m_PicDescriptor->n[0]) / 2.0f, 0, 0 ); } else if ( m_PicDescriptor->dim == 2 ) { inData->SetDimensions( m_PicDescriptor->n[0] , m_PicDescriptor->n[1] , 1 ); size = m_PicDescriptor->n[0] * m_PicDescriptor->n[1]; inData->SetOrigin( ((float) m_PicDescriptor->n[0]) / 2.0f, ((float) m_PicDescriptor->n[1]) / 2.0f, 0 ); } else if ( m_PicDescriptor->dim >= 3 ) { inData->SetDimensions( m_PicDescriptor->n[0], m_PicDescriptor->n[1], m_PicDescriptor->n[2] ); size = m_PicDescriptor->n[0] * m_PicDescriptor->n[1] * m_PicDescriptor->n[2]; // Test //inData->SetOrigin( (float) m_PicDescriptor->n[0] / 2.0f, (float) m_PicDescriptor->n[1] / 2.0f, (float) m_PicDescriptor->n[2] / 2.0f ); inData->SetOrigin( 0, 0, 0 ); } else { inData->Delete () ; return; } inData->SetNumberOfScalarComponents(m_PixelType.GetNumberOfComponents()); if ( ( m_PixelType.GetType() == mitkIpPicInt || m_PixelType.GetType() == mitkIpPicUInt ) && m_PixelType.GetBitsPerComponent() == 1 ) { inData->SetScalarType( VTK_BIT ); scalars = vtkBitArray::New(); } else if ( m_PixelType.GetType() == mitkIpPicInt && m_PixelType.GetBitsPerComponent() == 8 ) { inData->SetScalarType( VTK_CHAR ); scalars = vtkCharArray::New(); } else if ( m_PixelType.GetType() == mitkIpPicUInt && m_PixelType.GetBitsPerComponent() == 8 ) { inData->SetScalarType( VTK_UNSIGNED_CHAR ); scalars = vtkUnsignedCharArray::New(); } else if ( m_PixelType.GetType() == mitkIpPicInt && m_PixelType.GetBitsPerComponent() == 16 ) { inData->SetScalarType( VTK_SHORT ); scalars = vtkShortArray::New(); } else if ( m_PixelType.GetType() == mitkIpPicUInt && m_PixelType.GetBitsPerComponent() == 16 ) { inData->SetScalarType( VTK_UNSIGNED_SHORT ); scalars = vtkUnsignedShortArray::New(); } else if ( m_PixelType.GetType() == mitkIpPicInt && m_PixelType.GetBitsPerComponent() == 32 ) { inData->SetScalarType( VTK_INT ); scalars = vtkIntArray::New(); } else if ( m_PixelType.GetType() == mitkIpPicUInt && m_PixelType.GetBitsPerComponent() == 32 ) { inData->SetScalarType( VTK_UNSIGNED_INT ); scalars = vtkUnsignedIntArray::New(); } else if ( m_PixelType.GetType() == mitkIpPicInt && m_PixelType.GetBitsPerComponent() == 64 ) { inData->SetScalarType( VTK_LONG ); scalars = vtkLongArray::New(); } else if ( m_PixelType.GetType() == mitkIpPicUInt && m_PixelType.GetBitsPerComponent() == 64 ) { inData->SetScalarType( VTK_UNSIGNED_LONG ); scalars = vtkUnsignedLongArray::New(); } else if ( m_PixelType.GetType() == mitkIpPicFloat && m_PixelType.GetBitsPerComponent() == 32 ) { inData->SetScalarType( VTK_FLOAT ); scalars = vtkFloatArray::New(); } else if ( m_PixelType.GetType() == mitkIpPicFloat && m_PixelType.GetBitsPerComponent() == 64 ) { inData->SetScalarType( VTK_DOUBLE ); scalars = vtkDoubleArray::New(); } else { inData->Delete(); return; } m_VtkImageData = inData; // allocate the new scalars scalars->SetNumberOfComponents(m_VtkImageData->GetNumberOfScalarComponents()); scalars->SetVoidArray(m_PicDescriptor->data, _mitkIpPicElements(m_PicDescriptor)*m_VtkImageData->GetNumberOfScalarComponents(), 1); m_VtkImageData->GetPointData()->SetScalars(scalars); scalars->Delete(); }
mitkIpPicDescriptor * MITKipPicGet( char *infile_name, mitkIpPicDescriptor *pic ) { mitkIpPicFile_t infile; mitkIpPicTag_t tag_name; mitkIpUInt4_t len; mitkIpUInt4_t to_read; size_t size; size_t number_of_elements; size_t bytes_per_element; size_t number_of_bytes; size_t block_size; size_t number_of_blocks; size_t remaining_bytes; size_t bytes_read; size_t block_nr; mitkIpUInt1_t* data; size_t ignored; infile = _mitkIpPicOpenPicFileIn( infile_name ); if( !infile ) { /*ipPrintErr( "mitkIpPicGet: sorry, error opening infile\n" );*/ return( NULL ); } /* read infile */ ignored = mitkIpPicFRead( tag_name, 1, 4, infile ); if( strncmp( "\037\213", tag_name, 2 ) == 0 ) { fprintf( stderr, "mitkIpPicGetHeader: sorry, can't read compressed file\n" ); return( NULL ); } else if( strncmp( mitkIpPicVERSION, tag_name, 4 ) != 0 ) { #ifndef CHILIPLUGIN if( pic == NULL ) pic = _MITKipPicOldGet( infile, NULL ); else _MITKipPicOldGet( infile, pic ); if( infile != stdin ) mitkIpPicFClose( infile ); #else return NULL; #endif return( pic ); } size = 0; if( pic == NULL ) pic = mitkIpPicNew(); else { size= _mitkIpPicSize(pic); if(pic->data == NULL) size = 0; } if( pic->info != NULL ) { _mitkIpPicFreeTags( pic->info->tags_head ); pic->info->tags_head = NULL; } ignored = mitkIpPicFRead( &(tag_name[4]), 1, sizeof(mitkIpPicTag_t)-4, infile ); strncpy( pic->info->version, tag_name, _mitkIpPicTAGLEN ); ignored = mitkIpPicFReadLE( &len, sizeof(mitkIpUInt4_t), 1, infile ); ignored = mitkIpPicFReadLE( &(pic->type), sizeof(mitkIpUInt4_t), 1, infile ); ignored = mitkIpPicFReadLE( &(pic->bpe), sizeof(mitkIpUInt4_t), 1, infile ); ignored = mitkIpPicFReadLE( &(pic->dim), sizeof(mitkIpUInt4_t), 1, infile ); ignored = mitkIpPicFReadLE( &(pic->n), sizeof(mitkIpUInt4_t), pic->dim, infile ); (void *)ignored; to_read = len - 3 * sizeof(mitkIpUInt4_t) - pic->dim * sizeof(mitkIpUInt4_t); #if 0 mitkIpPicFSeek( infile, to_read, SEEK_CUR ); #else pic->info->tags_head = _MITKipPicReadTags( pic->info->tags_head, to_read, infile, mitkIpPicEncryptionType(pic) ); #endif pic->info->write_protect = mitkIpFalse; if((size == 0) || (size != _mitkIpPicSize(pic))) { if( pic->data != NULL ) { free( pic->data ); pic->data = NULL; } #ifdef WIN if ((pic->hdata = GlobalAlloc( GMEM_MOVEABLE, _mitkIpPicSize(pic) )) != 0) pic->data = GlobalLock( pic->hdata ); #else pic->data = malloc( _mitkIpPicSize(pic) ); #endif } pic->info->pixel_start_in_file = mitkIpPicFTell( infile ); /* * data is read in blocks of size 'block_size' to prevent from * errors due to large file sizes (>=2GB) */ number_of_elements = _mitkIpPicElements(pic); bytes_per_element = pic->bpe / 8; number_of_bytes = number_of_elements * bytes_per_element; block_size = 1024*1024; /* Use 1 MB blocks. Make sure that block size is smaller than 2^31 */ number_of_blocks = number_of_bytes / block_size; remaining_bytes = number_of_bytes % block_size; bytes_read = 0; block_nr = 0; /*printf( "mitkIpPicGet: number of blocks to read is %ul.\n", number_of_blocks ); */ data = (mitkIpUInt1_t*) pic->data; if( pic->type == mitkIpPicNonUniform ) { for ( block_nr = 0 ; block_nr < number_of_blocks ; ++block_nr ) bytes_read += mitkIpPicFRead( data + ( block_nr * block_size ), 1, (unsigned int) block_size, infile ); bytes_read += mitkIpPicFRead( data + ( number_of_blocks * block_size ), 1, (unsigned int) remaining_bytes, infile ); } else { for ( block_nr = 0 ; block_nr < number_of_blocks ; ++block_nr ) bytes_read += mitkIpPicFReadLE( data + ( block_nr * block_size ), 1, (unsigned int) block_size, infile ); bytes_read += mitkIpPicFReadLE( data + ( number_of_blocks * block_size ), 1, (unsigned int) remaining_bytes, infile ); } if ( bytes_read != number_of_bytes ) { fprintf( stderr, "Error while reading, only %lu bytes were read! Eof indicator is %u.\n", (long unsigned int)bytes_read, mitkIpPicFEOF(infile) ); #ifndef USE_ZLIB fprintf( stderr, "(ferror indicates %u).\n", ferror(infile)); #endif } if( infile != stdin ) mitkIpPicFClose( infile ); #ifdef WIN GlobalUnlock( pic->hdata ); #endif return( pic ); }
mitkIpPicDescriptor * mitkIpPicGet( const char *infile_name, mitkIpPicDescriptor *pic ) { mitkIpPicFile_t infile; mitkIpPicTag_t tag_name; mitkIpUInt4_t len; mitkIpUInt4_t to_read; infile = _mitkIpPicOpenPicFileIn( infile_name ); if( !infile ) { /*ipPrintErr( "mitkIpPicGet: sorry, error opening infile\n" );*/ return( NULL ); } /* read infile */ mitkIpPicFRead( tag_name, 1, 4, infile ); if( strncmp( "\037\213", tag_name, 2 ) == 0 ) { fprintf( stderr, "mitkIpPicGetHeader: sorry, can't read compressed file\n" ); return( NULL ); } else if( strncmp( mitkIpPicVERSION, tag_name, 4 ) != 0 ) { if( pic == NULL ) pic = _mitkIpPicOldGet( infile, NULL ); else _mitkIpPicOldGet( infile, pic ); if( infile != stdin ) mitkIpPicFClose( infile ); return( pic ); } if( pic == NULL ) pic = mitkIpPicNew(); mitkIpPicClear( pic ); mitkIpPicFRead( &(tag_name[4]), 1, sizeof(mitkIpPicTag_t)-4, infile ); strncpy( pic->info->version, tag_name, _mitkIpPicTAGLEN ); mitkIpPicFReadLE( &len, sizeof(mitkIpUInt4_t), 1, infile ); mitkIpPicFReadLE( &(pic->type), sizeof(mitkIpUInt4_t), 1, infile ); mitkIpPicFReadLE( &(pic->bpe), sizeof(mitkIpUInt4_t), 1, infile ); mitkIpPicFReadLE( &(pic->dim), sizeof(mitkIpUInt4_t), 1, infile ); mitkIpPicFReadLE( &(pic->n), sizeof(mitkIpUInt4_t), pic->dim, infile ); to_read = len - 3 * sizeof(mitkIpUInt4_t) - pic->dim * sizeof(mitkIpUInt4_t); #if 0 mitkIpPicFSeek( infile, to_read, SEEK_CUR ); #else pic->info->tags_head = _mitkIpPicReadTags( pic->info->tags_head, to_read, infile, mitkIpPicEncryptionType(pic) ); #endif pic->info->write_protect = mitkIpFalse; #ifdef WIN if ((pic->hdata = GlobalAlloc( GMEM_MOVEABLE, _mitkIpPicSize(pic) )) != 0) pic->data = GlobalLock( pic->hdata ); #else pic->data = malloc( _mitkIpPicSize(pic) ); #endif pic->info->pixel_start_in_file = mitkIpPicFTell( infile ); if( pic->type == mitkIpPicNonUniform ) mitkIpPicFRead( pic->data, pic->bpe / 8, _mitkIpPicElements(pic), infile ); else mitkIpPicFReadLE( pic->data, pic->bpe / 8, _mitkIpPicElements(pic), infile ); if( infile != stdin ) mitkIpPicFClose( infile ); #ifdef WIN GlobalUnlock( pic->hdata ); #endif return( pic ); }
mitkIpPicDescriptor *mitkIpPicGetSlice( const char *infile_name, mitkIpPicDescriptor *pic, mitkIpUInt4_t slice ) { mitkIpPicFile_t infile; mitkIpPicTag_t tag_name; mitkIpUInt4_t len; mitkIpUInt4_t skip; int number = 1; unsigned long int picsize; if( infile_name == NULL ) infile = stdin; else if( strcmp(infile_name, "stdin") == 0 ) infile = stdin; else infile = _mitkIpPicOpenPicFileIn( infile_name ); if( infile == NULL ) { /*ipPrintErr( "mitkIpPicGetSlice: sorry, error opening infile\n" );*/ return( NULL ); } /* read infile */ mitkIpPicFRead( &(tag_name[0]), 1, 4, infile ); if( strncmp( mitkIpPicVERSION, tag_name, 4 ) != 0 ) { if( pic == NULL ) pic = _mitkIpPicOldGetSlice( infile, NULL, slice ); else _mitkIpPicOldGetSlice( infile, pic, slice ); if( infile != stdin ) mitkIpPicFClose( infile ); return( pic ); } if( (void*)pic == (void*)3 ) { pic = NULL; number = 3; } if( pic == NULL ) pic = mitkIpPicNew(); mitkIpPicClear( pic ); mitkIpPicFRead( &(tag_name[4]), 1, sizeof(mitkIpPicTag_t)-4, infile ); strncpy( pic->info->version, tag_name, _mitkIpPicTAGLEN ); mitkIpPicFReadLE( &len, sizeof(mitkIpUInt4_t), 1, infile ); mitkIpPicFReadLE( &(pic->type), sizeof(mitkIpUInt4_t), 1, infile ); mitkIpPicFReadLE( &(pic->bpe), sizeof(mitkIpUInt4_t), 1, infile ); mitkIpPicFReadLE( &(pic->dim), sizeof(mitkIpUInt4_t), 1, infile ); mitkIpPicFReadLE( &(pic->n), sizeof(mitkIpUInt4_t), pic->dim, infile ); skip = len - 3 * sizeof(mitkIpUInt4_t) - pic->dim * sizeof(mitkIpUInt4_t); mitkIpPicFSeek( infile, skip, SEEK_CUR ); picsize = _mitkIpPicSize(pic); pic->dim = 2; if( slice < 1 || slice > picsize / _mitkIpPicSize(pic) ) { mitkIpPicClear( pic ); return( pic ); } if( number < 1 ) number = 1; if( slice + number - 1 > pic->n[2] ) number = pic->n[2] - slice + 1; pic->info->write_protect = mitkIpTrue; picsize = _mitkIpPicSize(pic); mitkIpPicFSeek( infile, picsize * (slice - 1), SEEK_CUR ); if( number > 1 ) { pic->dim = 3; pic->n[2] = number; } picsize = _mitkIpPicSize(pic); pic->data = malloc( picsize ); mitkIpPicFReadLE( pic->data, pic->bpe / 8, _mitkIpPicElements(pic), infile ); if( infile != stdin ) mitkIpPicFClose( infile ); return( pic ); }
mitkIpPicDescriptor *mitkIpFuncGausF ( mitkIpPicDescriptor *pic_old, mitkIpUInt4_t len_mask, mitkIpUInt4_t dim_mask, mitkIpFuncFlagI_t border ) { mitkIpPicDescriptor *pic_new; /* pointer to new image structure */ mitkIpPicDescriptor *pic_mask; /* pointer to mask */ mitkIpUInt4_t n[_mitkIpPicNDIM]; /* size of each dimension */ mitkIpUInt4_t ind[_mitkIpPicNDIM]; /* loop index vector */ mitkIpUInt4_t i, k; /* loop index */ mitkIpUInt4_t no_elem; /* number of mask elements */ mitkIpUInt4_t offset; /* offset of pixels */ mitkIpUInt4_t element; /* used to calculate mask elements */ mitkIpUInt4_t sum; /* sum of all mask elements */ mitkIpUInt4_t nn, nfac, kfac; /* used to calculate bin. coeff */ mitkIpUInt4_t *bin; /* binomial coeffizients */ /* check data */ if ( _mitkIpFuncError ( pic_old ) != mitkIpFuncOK ) return ( mitkIpFuncERROR ); if ( pic_old->dim < dim_mask || dim_mask < 1 ) { _mitkIpFuncSetErrno ( mitkIpFuncDIMMASC_ERROR ); return ( mitkIpFuncERROR ); } if ( len_mask % 2 != 1 ) { _mitkIpFuncSetErrno ( mitkIpFuncDIM_ERROR ); return ( mitkIpFuncERROR ); } /* calculate binomial coefficient */ bin = malloc ( len_mask * sizeof ( mitkIpUInt4_t ) ); if ( bin == NULL ) { _mitkIpFuncSetErrno ( mitkIpFuncMALLOC_ERROR ); return ( mitkIpFuncERROR ); } nn = len_mask; bin[0] = 1; bin[nn-1] = 1; nfac = 1; kfac = 1; for ( k = 1; k < nn-1; k++ ) { kfac = k * kfac; nfac = nfac * ( nn - k ); bin[k] = nfac / kfac; } /* initialize mask */ pic_mask = mitkIpPicNew(); if ( pic_mask == NULL ) { free ( bin ); _mitkIpFuncSetErrno ( mitkIpFuncPICNEW_ERROR ); return ( mitkIpFuncERROR ); } pic_mask->type = mitkIpPicFloat; pic_mask->bpe = 64; pic_mask->dim = dim_mask; for ( i = 0; i < dim_mask; i++ ) pic_mask->n[i] = len_mask; pic_mask->data = malloc ( _mitkIpPicSize ( pic_mask ) ); if ( pic_mask->data == NULL ) { free ( bin ); mitkIpPicFree ( pic_mask ); _mitkIpFuncSetErrno ( mitkIpFuncPICNEW_ERROR ); return ( mitkIpFuncERROR ); } /* initialize vectors */ for ( i = 0; i < pic_mask->dim; i++ ) n[i] = len_mask; for ( i = pic_mask->dim; i < _mitkIpPicNDIM; i++ ) n[i] = 1; /* calculate mask */ offset = 0; sum = 0; for ( ind[7] = 0; ind[7] < n[7]; ind[7]++ ) for ( ind[6] = 0; ind[6] < n[6]; ind[6]++ ) for ( ind[5] = 0; ind[5] < n[5]; ind[5]++ ) for ( ind[4] = 0; ind[4] < n[4]; ind[4]++ ) for ( ind[3] = 0; ind[3] < n[3]; ind[3]++ ) for ( ind[2] = 0; ind[2] < n[2]; ind[2]++ ) for ( ind[1] = 0; ind[1] < n[1]; ind[1]++ ) for ( ind[0] = 0; ind[0] < n[0]; ind[0]++ ) { element = 1; for ( i = 0; i < pic_mask->dim; i++ ) element = element * bin[ind[i]]; (( mitkIpFloat8_t * )pic_mask->data)[offset] = ( mitkIpFloat8_t ) element; sum = sum + element; offset++; } no_elem = _mitkIpPicElements ( pic_mask ); for ( i = 0; i < no_elem; i++ ) (( mitkIpFloat8_t * ) pic_mask->data ) [i] = (( mitkIpFloat8_t * ) pic_mask->data ) [i] / ( mitkIpFloat8_t ) sum; /* convolve image with Gausian mask */ pic_new = mitkIpFuncConv ( pic_old, pic_mask, border ); mitkIpPicFree ( pic_mask ); free ( bin ); /* Copy Tags */ mitkIpFuncCopyTags(pic_new, pic_old); return ( pic_new ); }