Esempio n. 1
0
/*-------------------------------------------------------------------
* CTWriteSLC - write a slice in SLC format
*-------------------------------------------------------------------
*/
static int CTWriteSLC(CTSlice slice)
{
	switch (CTVolVoxelBits(slice->vol)) 
	{
		case CT_8BIT:
			fwrite(slice->cdata, sizeof(char), CTVolXSize(slice->vol)*
				CTVolYSize(slice->vol), slice->vol->outfp);
			break;

		case CT_16BIT:
			fwrite(slice->data, sizeof(short), CTVolXSize(slice->vol)*
				CTVolYSize(slice->vol), slice->vol->outfp);
			break;
	}
	return 0;
}
Esempio n. 2
0
/*-------------------------------------------------------------------
* CTReadH3D - read a slice from an H3D file
*-------------------------------------------------------------------
*/
static int CTReadH3D(FILE *fp, CTSlice slice, int num, int x1, int y1,
                     int x2, int y2)
{
	if (x1==-1) 
	{
		slice->x1=slice->y1=x1=y1=0;
		slice->x2=x2=CTSliceXSize(slice)-1;
		slice->y2=y2=CTSliceYSize(slice)-1;
		slice->fdata=(float *)malloc(sizeof(float)*(x2-x1+1)*(y2-y1+1));
		memset(slice->fdata, '\0', sizeof(float)*(x2-x1+1)*(y2-y1+1));
	}
	
	CTSliceWidth(slice) = x2-x1+1;
	CTSliceHeight(slice) = y2-y1+1;
	
	fskip(fp, sizeof(int)*3 + sizeof(double)*3 +
		CTVolXSize(slice->vol)*CTVolYSize(slice->vol)*(num-1)*sizeof(float));
	fread(slice->fdata, sizeof(float), CTVolXSize(slice->vol)*
		CTVolYSize(slice->vol), fp);
	
	CTSliceCompMinMaxD(slice);
	return(0);
}
Esempio n. 3
0
CTVolume
CTVolumeHartley3D(CTVolume vol)
{
	CTVolume vol2;
	CTSlice slice;
	int l,m,n,L,M,N,i,j,k;
	
	#ifdef USE_PTIME
		int t1,t2;
	#endif
	
	float *d1,*d2,*X,*D,Z,*w,*w1,*w2;
	float *Mcas, *Lcos, *Lsin, *Ncos, *Nsin, max, min;
	double dL, dM, dN, s, c;
	
	/* Get source volume info. */
	L = CTVolXSize(vol);
	M = CTVolYSize(vol);
	N = CTVolNumSlices(vol);
	dL = (double)L;
	dM = (double)M;
	dN = (double)N;
	
	/* Initialize the new volume. */
	vol2 = CTVolumeCreate(CTH3D,CTVolPrefix(vol),".h3d",CTVolXSize(vol),
		CTVolYSize(vol),CTVolZSize(vol),CTVolXSep(vol),
		CTVolYSep(vol),CTVolZSep(vol),CTVolFirstSlice(vol),
		CTVolLastSlice(vol),1.0e10,CT_MSBF,CT_FLOAT);
	
	/* Open the new volume for writing. */
	CTVolumeOpen(vol2,CTH3D,CTVolPrefix(vol2),".h3d");
	
	/* Read in the volume data. */
	D = (float *)malloc(L*M*N*sizeof(float));

	switch (CTVolVoxelBits(vol)) 
	{
		
		/* Read in and convert CT_8BIT values to CT_FLOAT. */
		case CT_8BIT:
			for (n=0;n<N;n++) 
			{
				slice = CTSliceRead(vol,n+CTVolFirstSlice(vol),-1,-1,-1,-1);
				for (l=0;l<L;l++) 
				{
					for (m=0;m<M;m++) 
					{
						D[n+N*(l+L*m)] = (float)CTSliceCharData(slice,l,m);
					}
				}
				CTSliceFree(slice);
			}
			break;
			
			/* Read in and convert CT_16BIT values to CT_FLOAT. */
		case CT_16BIT:
			for (n=0;n<N;n++) 
			{
				slice = CTSliceRead(vol,n+CTVolFirstSlice(vol),-1,-1,-1,-1);
				for (l=0;l<L;l++) 
				{
					for (m=0;m<M;m++) 
					{
						D[n+N*(l+L*m)] = (float)CTSliceShortData(slice,l,m);
					}
				}
				CTSliceFree(slice);
			}
			break;
			
			/* Read in CT_FLOAT values. */
		case CT_FLOAT:
			for (n=0;n<N;n++) 
			{
				slice = CTSliceRead(vol,n+CTVolFirstSlice(vol),-1,-1,-1,-1);
				for (l=0;l<L;l++) 
				{
					for (m=0;m<M;m++) 
					{
						D[n+N*(l+L*m)] = CTSliceFloatData(slice,l,m);
					}
				}
				CTSliceFree(slice);
			}
			break;
	}
	
	/* Precompute necessary sin, cos, and cas function values. */
	Lcos = (float *)malloc(sizeof(float)*L*L);
	Lsin = (float *)malloc(sizeof(float)*L*L);
	Ncos = (float *)malloc(sizeof(float)*N*N);
	Nsin = (float *)malloc(sizeof(float)*N*N);
	Mcas = (float *)malloc(sizeof(float)*M*M);

	for (i=0;i<L*L;i++) 
	{
		s = sin(2.0*M_PI*(double)i/dL);
		c = cos(2.0*M_PI*(double)i/dL);
		Lcos[i] = (float)c;
		Lsin[i] = (float)s;
	}
	
	for (i=0;i<N*N;i++) 
	{
		s = sin(2.0*M_PI*(double)i/dN);
		c = cos(2.0*M_PI*(double)i/dN);
		Ncos[i] = (float)c;
		Nsin[i] = (float)s;
	}
	
	for (i=0;i<M*M;i++) 
	{
		s = sin(2.0*M_PI*(double)i/dM);
		c = cos(2.0*M_PI*(double)i/dM);
		Mcas[i] = (float)(s+c);
	}
	
	/* Algorithm is O(LLMN+LMMN+LMNN). */
	X = (float *)malloc(L*M*sizeof(float));
	w1 = (float *)malloc(L*M*sizeof(float));
	w2 = (float *)malloc(M*sizeof(float));
	
#ifdef USE_PTIME
	t1 = t2 = time(NULL);
#endif
	
	/*
    Transfrom the original volume and write the new volume one slice at
    a time, in order.
	*/
	for (k=0;k<N;k++) 
	{
		
		/* Initialize max and min values for each slice. */
		min = 1.0e10;
		max = -1.0e10;
		
		/* Compute w1(i,m,n) */
		d1 = D;
		w = w1;
		for (m=0;m<M;m++) 
		{
			for (l=0;l<L;l++) 
			{
				d2 = &D[N*((L-l)%L+L*((M-m)%M))];
				*w = 0.0;
				
				for (n=0;n<N;n++) 
				{
					*w += (*d1++)*Ncos[k*n]+(*d2++)*Nsin[k*n];
				}
				
				w++;
			}
		}
		
		/* Compute w2(i,j,n) */
		for (i=0;i<L;i++) 
		{
			w = w2;
			d1 = w1;
			for (m=0;m<M;m++) 
			{
				*w = 0.0;
				d2 = &w1[L*((M-m)%M)];
				
				for (l=0;l<L;l++) 
				{
					*w += (*d1++)*Lcos[i*l]+(*d2++)*Lsin[i*l];
				}
				
				w++;
			}
			
			/* Compute X(i,j,k) */
			for (j=0;j<M;j++) 
			{
				Z = 0.0;
				w = w2;
				
				for (m=0;m<M;m++) 
				{
					Z += (*w++)*Mcas[j*m];
				}
				
				if (Z>max) max = Z;
				if (Z<min) min = Z;
				X[i+L*j] = Z;
			}
		}
		
		/* Write the transformed slice. */
		slice = CTSliceCreate(L,M,min,max,vol2,k);

		for (i=0;i<L;i++) 
		{
			for (j=0;j<M;j++) 
			{
				CTSliceSetVal(slice,i,j,X[i+L*j]);
			}
		}
		CTSliceWrite(NULL,slice);
		CTSliceFree(slice);
		
#ifdef USE_PTIME
		printf("Slice %d/%d, ",k+1,N);
		ptime((int)((float)(time(NULL)-t1)/(float)(k+1)*(float)(N-k-1)));
		printf("\n");
#endif
		
	}
	
	/* Done writing to the new volume. */
	CTVolumeClose(vol2);
	
#ifdef USE_PTIME
	t2 = time(NULL);
	printf("(3D)Total time: ");
	ptime(t2-t1);
	printf("\n");
#endif
	
	/* Return the transformed volume. */
	return(vol2);
}
Esempio n. 4
0
/*-------------------------------------------------------------------
* CTReadSLC - read a slice from an SLC file
*-------------------------------------------------------------------
*/
static int CTReadSLC(FILE *fp, CTSlice slice, int num, int x1, int y1,
                     int x2, int y2)
{
	int i, remaining, current_value;
	unsigned int size;
//	unsigned int xsize, ysize, zsize, bits, magic;
//	float xunit, yunit, zunit;
	unsigned char *data_ptr;
	C_CompressionType compression;
//	C_UnitType unit;
//	C_DataOrigin data;
//	C_DataModification datamod;
	
	if (x1==-1) 
	{
		slice->x1=slice->y1=x1=y1=0;
		slice->x2=x2=CTSliceXSize(slice)-1;
		slice->y2=y2=CTSliceYSize(slice)-1;
		slice->cdata=(unsigned char *)malloc(sizeof(char)*(x2-x1+1)*(y2-y1+1));
		memset(slice->cdata, '\0', sizeof(char)*(x2-x1+1)*(y2-y1+1));
	}
	
	CTSliceWidth(slice) = x2-x1+1;
	CTSliceHeight(slice) = y2-y1+1;
	
	/* skip header */
	fskip(fp, sizeof(int)*5 + sizeof(float)*3 + sizeof(C_UnitType) +
		sizeof(C_DataOrigin) + sizeof(C_DataModification));
	
	/* get compression type */
	fread(&compression, sizeof(C_CompressionType), 1, fp);
	
	/* skip (num-1) slices */
	if (compression == C_NO_COMPRESSION) 
	{
		fskip(fp, CTVolXSize(slice->vol)*CTVolYSize(slice->vol)*(num-1));
	}
	else 
	{
		for (i=0; i<num-1; i++) 
		{
			fread(&size, sizeof(int), 1, fp);
			fskip(fp, size);
		}
	}
	
	/* read slice */
	switch (compression) 
	{
		case C_NO_COMPRESSION:
			fread(slice->cdata, sizeof(char),
				CTVolXSize(slice->vol)*CTVolYSize(slice->vol), fp);
			break;

		case C_RUN_LENGTH_ENCODE:
			fread(&size, sizeof(int), 1, fp);
			data_ptr = slice->cdata;
			while (1) 
			{
				current_value = getc(fp);
				if ( !(remaining = (current_value & 0x7f)) )
					break;
				if ( current_value & 0x80 )
					while (remaining--)
						*(data_ptr++) = getc(fp);
					else 
					{
						current_value = getc(fp);
						while (remaining--)
							*(data_ptr++) = current_value;
					}
			}
			break;

		default:
			fprintf(stderr, "Error in compression type of SLC file\n");
			return(-1);
	}
	
	CTSliceCompMinMaxD(slice);
	return(0);
}
Esempio n. 5
0
/*-------------------------------------------------------------------
* CTWriteH3D - write a slice in H3D format
*-------------------------------------------------------------------
*/
static int CTWriteH3D(CTSlice slice)
{
	fwrite(slice->fdata, sizeof(float), CTVolXSize(slice->vol)*
		CTVolYSize(slice->vol), slice->vol->outfp);
	return 0;
}