void mitk::DopplerToStrainRateFilter::GenerateData() { mitk::Image::ConstPointer input = this->GetInput(); mitk::Image::Pointer output = this->GetOutput(); mitk::Point3iProperty::Pointer pointProp; pointProp = dynamic_cast<mitk::Point3iProperty*>(input->GetProperty("ORIGIN").GetPointer()); if (pointProp.IsNotNull() ) { m_Origin = pointProp->GetValue(); } MITK_INFO << "compute Strain Rate Image .... " << std::endl << " origin[0]=" << m_Origin[0] << " origin[1]=" << m_Origin[1] << " origin[2]=" << m_Origin[2] << std::endl << " distance=" << m_Distance << std::endl << " NoStrainIntervall=" << m_NoStrainInterval << std::endl; const Vector3D & spacing = input->GetSlicedGeometry()->GetSpacing(); // MITK_INFO << " in: xres=" << spacing[0] << " yres=" << spacing[1] << " zres=" << spacing[2] << std::endl; mitk::ImageTimeSelector::Pointer timeSelector=mitk::ImageTimeSelector::New(); timeSelector->SetInput(input); mitkIpPicDescriptor* picStrainRate; picStrainRate = mitkIpPicNew(); picStrainRate->dim=3; picStrainRate->bpe = output->GetPixelType().GetBpe(); //picStrainRate->type = output->GetPixelType().GetType(); picStrainRate->n[0] = output->GetDimension(0); picStrainRate->n[1] = output->GetDimension(1); picStrainRate->n[2] = output->GetDimension(2); picStrainRate->data=malloc(_mitkIpPicSize(picStrainRate)); int xDim = picStrainRate->n[0]; int yDim = picStrainRate->n[1]; int zDim = picStrainRate->n[2]; long slice_size = xDim*yDim; long vol_size = slice_size*zDim; mitkIpPicDescriptor *picDoppler; int x,y,z;//,time; // loop-counter int strainRate; // the computed Strain Rate int v1,v2; // velocity and Point p1 and p2 float alpha; // the beam-angle, angle betwen current point and beam-point float dx=0, dy=0; // projection of this->distance to x- and y-axis int x1; // a square, where the velocity v1 lies in int y1; // the points are used for interpolation int minStrainRate=128, maxStrainRate=128; int n, nmax; int t, tmax; t = output->GetRequestedRegion().GetIndex(3); n = output->GetRequestedRegion().GetIndex(4); MITK_INFO << "t = " <<t << " n = " << n << std::endl; tmax = t + output->GetRequestedRegion().GetSize(3); nmax = n + output->GetRequestedRegion().GetSize(4); MITK_INFO << "tmax = "<< tmax << " nmax = " << nmax << std::endl; if (m_Distance<1) m_Distance=1; for(;n<nmax;n++)//output->GetNumberOfChannels();++n) { timeSelector->SetChannelNr(n); MITK_INFO << "computing chanel n = " << n << std::endl; for(t=0;t<tmax;t++) { MITK_INFO << "computing time slot t = " << t << std::endl; timeSelector->SetTimeNr(t); timeSelector->Update(); // Cast to pic descriptor for the timeSelector image mitkIpPicDescriptor* timeSelectorPic = mitkIpPicNew(); CastToIpPicDescriptor( timeSelector->GetOutput(), timeSelectorPic ); _mitkIpPicFreeTags(picStrainRate->info->tags_head); picStrainRate->info->tags_head = _mitkIpPicCloneTags(timeSelectorPic->info->tags_head); //#define WRITE_ANGLE_PIC #ifdef WRITE_ANGLE_PIC mitkIpPicDescriptor *anglePic; mitkIpBool_t isAnglePicWritten = mitkIpFalse; anglePic = mitkIpPicNew(); anglePic->type = mitkIpPicInt; anglePic->bpe = 8; anglePic->dim = 2; anglePic->n[0] = xDim; anglePic->n[1] = yDim; anglePic->data = (mitkIpInt1_t *)calloc(xDim*yDim,sizeof(mitkIpInt1_t)); #endif picDoppler = timeSelectorPic; picDoppler = mitkIpFuncGausF( picDoppler, 5,2 , mitkIpFuncBorderOld ) ; for (z=0 ; z<zDim ; z++) { for (y=1; y<yDim; y++) { if (y<m_Origin[1]) continue; // cannot compute StrainRate above Transducer-Position for (x=0; x<xDim; x++) { if ((m_Origin[0] - x)==0) { // winkelhalbierende int yDistanceInUnits = (int)( m_Distance/spacing[1]); int yTmp = ( (y-yDistanceInUnits)<0 ) ? 0 : (y-yDistanceInUnits); v1 = ((mitkIpUInt1_t *)picDoppler->data)[z*slice_size + yTmp*xDim + x] ; v2 = ((mitkIpUInt1_t *)picDoppler->data)[z*slice_size + y*xDim + x] ; } else { // compute angle to transducer position // m_Origin is given in units, not in mm alpha = atan( (float) (m_Origin[0] - x) / (float) (m_Origin[1] - y) ); // m_Distance is given in mm dx = -sin(alpha) * m_Distance; dy = -cos(alpha) * m_Distance; // convert to units dx = dx/spacing[0]; dy = dy/spacing[1]; //#define WEIGTHED #ifdef WEIGTHED weightX = dx - floor(dx); weightY = dy - floor(dy); dxFloor = (int) floor(dx); dyFloor = (int) floor(dy); x1 = x + dxFloor; // lower left y1 = y + dyFloor; x2 = x + (dxFloor+1); // lower right y2 = y + dyFloor; x3 = x + (dxFloor+1); // upper right y3 = y + (dyFloor+1); x4 = x + dxFloor; // upper left y4 = y + (dyFloor+1); vTmp1 = ((mitkIpUInt1_t *)picDoppler->data)[z*slice_size + y1*xDim + x1]; vTmp2 = ((mitkIpUInt1_t *)picDoppler->data)[z*slice_size + y2*xDim + x2]; vTmp3 = ((mitkIpUInt1_t *)picDoppler->data)[z*slice_size + y3*xDim + x3]; vTmp4 = ((mitkIpUInt1_t *)picDoppler->data)[z*slice_size + y4*xDim + x4]; v1 = (int) ((1-weightX)*(1-weightY)*vTmp1 + weightX*(1-weightY)*vTmp2 + weightX*weightY*vTmp3 + (1-weightX)*weightY*vTmp4); v2 = ((mitkIpUInt1_t *)picDoppler->data)[z*slice_size + y*xDim + x] ; #else x1 = (int)(x + dx); y1 = (int)(y + dy); if (y1<0) y1=0; #endif v1 = ((mitkIpUInt1_t *)picDoppler->data)[z*slice_size + y1*xDim + x1]; v2 = ((mitkIpUInt1_t *)picDoppler->data)[z*slice_size + y*xDim + x] ; } if (v1==128) { // schaue in Gegenrichtung, falls keine SRI hier berechenbar x1 = (int)(x - dx); y1 = (int)(y - dy); if (y1>yDim) y1=yDim; //swap v1 and v2, otherwise StrainRate is calculate in false direction v1 = v2; v2 = ((mitkIpUInt1_t *)picDoppler->data)[z*slice_size + y1*xDim + x1]; } if ( (v1==0 ) || (v2==0) || // wenn keine Geschwindigkeit vorhanden // oder wenn nur ganz kleine Geschwindigkeit vorhanden (v1>=(128-m_NoStrainInterval) && v1<=(128+m_NoStrainInterval)) || (v2>=(128-m_NoStrainInterval) && v2<=(128+m_NoStrainInterval))) { strainRate = 128; // this means no deformation // this is neccessay due to the Cyl2Cart filter } else { strainRate = (int)( (v1 - v2)/2 + 128 ); if (strainRate==128) strainRate=129; } if (strainRate < minStrainRate && strainRate > 0 ) minStrainRate = strainRate; if (strainRate > maxStrainRate) maxStrainRate = strainRate; if (strainRate<0 ) { //strainRate = -strainRate; MITK_INFO << " error: neg. strainRate ... exit() " << std::endl << " x=" << x << " y=" << y << " z=" << z << std::endl << " v1=" << v1 << " v2=" << v2 << " dist=" << m_Distance << std::endl << " sr=" << strainRate << std::endl; exit(0); } ((mitkIpUInt1_t *)picStrainRate->data)[t*vol_size + z*slice_size + y*xDim + x]=strainRate; // cout << "z: " << z << " y: " << y << " x: " << x << " strainrate: " << strainRate << endl; #ifdef WRITE_ANGLE_PIC // if (!isAnglePicWritten) // ((mitkIpInt1_t *)anglePic->data)[y*xDim + x] = (int) ( (alpha/1.6)*128); if (!isAnglePicWritten) ((mitkIpInt1_t *)anglePic->data)[y*xDim + x] = (int) ( dx); #endif } // x } // y //isAnglePicWritten = mitkIpTrue; } // z //isStrainComputed = mitkIpTrue; std::string filenameD; filenameD ="doppler.pic"; mitkIpPicPut(const_cast<char *>(filenameD.c_str()),picDoppler); #define WRITE_STRAIN_PIC #ifdef WRITE_STRAIN_PIC char tmpfilename[100]; sprintf(tmpfilename,"strain%d.pic",t);; mitkIpPicPut(tmpfilename,picStrainRate); #endif #ifdef WRITE_ANGLE_PIC std::string filename2; filename2="angle.pic"; mitkIpPicPut(const_cast<char *>(filename2.c_str()),anglePic); #endif ((mitkIpUInt1_t *)picStrainRate->data)[0]=0; ((mitkIpUInt1_t *)picStrainRate->data)[1]=255; output->SetVolume(picStrainRate->data, t, n); } } mitkIpPicFree(picStrainRate); #define WRITE_STRAIN_PIC #ifdef WRITE_STRAIN_PIC // Get the StrainRate ipPic descriptor picStrainRate = mitkIpPicNew(); CastToIpPicDescriptor( output, picStrainRate ); std::string filename; filename ="strain.pic"; mitkIpPicPut(const_cast<char *>(filename.c_str()),picStrainRate); #endif MITK_INFO << "Strain Rate Image computed.... " << std::endl << " minStrainRate: " << minStrainRate << std::endl << " maxStrainRate: " << maxStrainRate << std::endl; }
void mitk::CylindricToCartesianFilter::GenerateData() { mitk::Image::ConstPointer input = this->GetInput(); mitk::Image::Pointer output = this->GetOutput(); mitk::ImageTimeSelector::Pointer timeSelector=mitk::ImageTimeSelector::New(); timeSelector->SetInput(input); mitkIpPicDescriptor* pic_transformed=NULL; pic_transformed = mitkIpPicNew(); pic_transformed->dim=3; pic_transformed->bpe = output->GetPixelType().GetBpe(); //pic_transformed->type = output->GetPixelType().GetType(); pic_transformed->n[0] = output->GetDimension(0); pic_transformed->n[1] = output->GetDimension(1); pic_transformed->n[2] = output->GetDimension(2); pic_transformed->data=malloc(_mitkIpPicSize(pic_transformed)); int nstart, nmax; int tstart, tmax; tstart=output->GetRequestedRegion().GetIndex(3); nstart=output->GetRequestedRegion().GetIndex(4); tmax=tstart+output->GetRequestedRegion().GetSize(3); nmax=nstart+output->GetRequestedRegion().GetSize(4); if(zt==NULL) { timeSelector->SetChannelNr(nstart); timeSelector->SetTimeNr(tstart); buildTransformShortCuts(input->GetDimension(0),input->GetDimension(1), input->GetDimension(2), output->GetDimension(0), rt_pic, phit_pic, fr_pic, fphi_pic, zt, fz); // query the line limiting the sector a=b=0; mitk::FloatProperty::Pointer prop; prop = dynamic_cast<mitk::FloatProperty*>(input->GetProperty("SECTOR LIMITING LINE SLOPE").GetPointer()); if (prop.IsNotNull() ) a = prop->GetValue(); prop = dynamic_cast<mitk::FloatProperty*>(input->GetProperty("SECTOR LIMITING LINE OFFSET").GetPointer()); if (prop.IsNotNull() ) b = prop->GetValue(); buildConeCutOffShortCut(input->GetDimension(0),input->GetDimension(1), rt_pic, fr_pic, a, b, coneCutOff_pic); // mitkIpPicPut("C:\\temp\\rt_90.pic",rt_pic); //mitkIpPicPut("C:\\temp\\coneCutOff.pic", coneCutOff_pic); } int n,t; for(n=nstart;n<nmax;++n)//output->GetNumberOfChannels();++n) { timeSelector->SetChannelNr(n); for(t=tstart;t<tmax;++t) { timeSelector->SetTimeNr(t); timeSelector->Update(); // Cast to pic descriptor for the timeSelector image mitkIpPicDescriptor* timeSelectorPic = mitkIpPicNew(); CastToIpPicDescriptor( timeSelector->GetOutput(), timeSelectorPic ); _mitkIpPicFreeTags(pic_transformed->info->tags_head); pic_transformed->info->tags_head = _mitkIpPicCloneTags(timeSelectorPic->info->tags_head); if(input->GetDimension(2)>1) { mitkIpPicTypeMultiplex9(_transform, timeSelectorPic , pic_transformed, m_OutsideValue, (float*)fr_pic->data, (float*)fphi_pic->data, fz, (short *)rt_pic->data, (unsigned int *)phit_pic->data, zt, coneCutOff_pic); // mitkIpPicPut("1trf.pic",pic_transformed); } else { mitkIpPicDescriptor *doubleSlice = mitkIpPicCopyHeader( timeSelectorPic , NULL); doubleSlice->dim=3; doubleSlice->n[2]=2; doubleSlice->data=malloc(_mitkIpPicSize(doubleSlice)); memcpy(doubleSlice->data, timeSelectorPic->data, _mitkIpPicSize(doubleSlice)/2); mitkIpPicTypeMultiplex9(_transform, doubleSlice, pic_transformed, m_OutsideValue, (float*)fr_pic->data, (float*)fphi_pic->data, fz, (short *)rt_pic->data, (unsigned int *)phit_pic->data, zt, coneCutOff_pic); mitkIpPicFree(doubleSlice); } output->SetVolume(pic_transformed->data, t, n); } } //mitkIpPicPut("outzzzzzzzz.pic",pic_transformed); mitkIpPicFree(pic_transformed); m_TimeOfHeaderInitialization.Modified(); }
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 ); }