main.c

完整的3D 模型检索程序

		for(destCam=0; destCam<ANGLE; destCam++)
		{
			sprintf(filename, "12_%d", destCam);
			ReadObj(filename, CamVertex+destCam, CamTriangle+destCam, CamNumVer+destCam, CamNumTri+destCam);
		}

		for(i=0; i<CAMNUM; i++)
		{
			srcBuff[i] = (unsigned char *) malloc (winw * winh * sizeof(unsigned char));
			ColorBuff[i] = (unsigned char *) malloc (3 * winw * winh * sizeof(unsigned char));
		}
		YuvBuff = (unsigned char *) malloc (3 * winw * winh * sizeof(unsigned char));
		// add edge to test retrieval
		EdgeBuff = (unsigned char *) malloc (winw * winh * sizeof(unsigned char));
		fpt1 = fopen("list.txt", "r");
		fpt4 = fopen("all.ccd", "wb");
		while( fgets(fname, 400, fpt1) )
		{
			// record execute time --- start
			start = clock();

			fname[strlen(fname)-1] = 0x00;
			// get the translatation and scale of the two model
			if( ReadObj(fname, &vertex1, &triangle1, &NumVer1, &NumTri1) == 0 )
				continue;

			// ****************************************************************
			// Corase alignment
			// ****************************************************************

			// Translate and scale model 1
			TranslateScale(vertex1, NumVer1, triangle1, NumTri1, fname, &Translate1, &Scale1);

			// read RED only, so size is winw*winh
			for(srcCam=0; srcCam<ANGLE; srcCam++)
			{
				// capture CAMNUM silhouette of srcfn to memory
				for(i=0; i<CAMNUM; i++)
					RenderToMem(srcBuff[i], ColorBuff[i], CamVertex[srcCam]+i, vertex1, triangle1, NumVer1, NumTri1);

				// from silhouette
//				for(i=0; i<CAMNUM; i++)
//				{
//					EdgeDetectSil(srcBuff[i], winw, winh);
//					sprintf(fn, "%s_%2d_%02d.bmp", fname, srcCam, i);
//					WriteBitmap8(srcBuff[i], winw, winh, fn);
//				}

				// get color descriptor
				for(i=0; i<CAMNUM; i++)
				{
					RGB_To_YUV(YuvBuff, ColorBuff[i], WIDTH, HEIGHT);
					ExtractCCD(YuvBuff, CompactColor[srcCam]+i, srcBuff[i]); // use srcBuff[i] as mask
					// print the results of compact color
//					for(j=0; j<NUM_BINS-1; j++)
//						if( CompactColor[i] & (0x8000000000000000 >> j) )
//							printf("1");
//						else
//							printf("0");
//					printf("\n");
				}

//				FindRadius(srcBuff);

//				for(i=0; i<CAMNUM; i++)
//				{
					// from depth
					// EdgeDetect(EdgeBuff, srcBuff[i], winw, winh);
//					WriteBitmap8(srcBuff[i], winw, winh, "test1.bmp");
//					WriteBitmap8(EdgeBuff, winw, winh, "test2.bmp");
//					ExtractCoefficients(srcBuff[i], src_ArtCoeff[srcCam][i], EdgeBuff);
//				}
			}

			// free memory of 3D model
			free(vertex1);
			free(triangle1);

			// record execute time --- end
			finish = clock();
			fpt = fopen("feature_time.txt", "a");
			fprintf(fpt, "%s ( V: %d T: %d )\t: %f sec;\n", fname, NumVer1, NumTri1, (double)(finish - start) / CLOCKS_PER_SEC );
			fclose(fpt);

			// save feature to file
/*			sprintf(filename, "%s.art", fname);
			fpt = fopen(filename, "wb");
			fwrite(src_ArtCoeff, ANGLE * CAMNUM * ART_ANGULAR * ART_RADIAL, sizeof(double), fpt);
			fclose(fpt);

			// linear Quantization to 8 bits for each coefficient
			for(i=0; i<ANGLE; i++)
				for(j=0; j<CAMNUM; j++)
				{
					src_ArtCoeff[i][j][0][0] = 1.0;

					for(p=0, k=0; p<ART_ANGULAR ; p++)
						for(r=0 ; r<ART_RADIAL ; r++, k++)
						{
							itmp = (int)(256 *  src_ArtCoeff[i][j][p][r]);
							if(itmp>255)
								q8_ArtCoeff[i][j][k] = 255;
							else
								q8_ArtCoeff[i][j][k] = itmp;
						}
				}
			// save to disk
			fwrite(q8_ArtCoeff, sizeof(unsigned char), ANGLE * CAMNUM * ART_COEF, fpt3);
			sprintf(filename, "%s_q8.art", fname);
			if( (fpt = fopen(filename, "wb")) == NULL )	{	printf("Write %s error!!\n", filename);	return;	}
			fwrite(q8_ArtCoeff, sizeof(unsigned char), ANGLE * CAMNUM * ART_COEF, fpt);
			fclose(fpt);

			// non-linear Quantization to 4 bits for each coefficient using MPEG-7 quantization table
			for(i=0; i<ANGLE; i++)
				for(j=0; j<CAMNUM; j++)
				{
					src_ArtCoeff[i][j][0][0] = 1;	// no need this coefficient

					for(p=0, k=0; p<ART_ANGULAR ; p++)
						for(r=0 ; r<ART_RADIAL ; r++, k++)
						{
							high = 17;
							low = 0;
							while(high-low > 1)
							{
								middle = (high+low) >> 1;	// (high+low)/2

								if(QuantTable[middle] < src_ArtCoeff[i][j][p][r])
									low = middle;
								else
									high = middle;
							}
							q8_ArtCoeff[i][j][k] = low;
						}
				}

			for(i=0; i<ANGLE; i++)
				for(j=0; j<CAMNUM; j++)
					for(k=0, a=0; k<ART_COEF; k+=2, a++)
//						q4_ArtCoeff[i][j][a] = q8_ArtCoeff[i][j][k] | (q8_ArtCoeff[i][j][k+1] << 4);
						q4_ArtCoeff[i][j][a] = ( q8_ArtCoeff[i][j][k] & 0x0f ) | 
											( (q8_ArtCoeff[i][j][k+1] << 4) & 0xf0 );

			// save to disk
			fwrite(q4_ArtCoeff, sizeof(unsigned char), ANGLE * CAMNUM * ART_COEF_2, fpt2);
			sprintf(filename, "%s_q4.art", fname);
			if( (fpt = fopen(filename, "wb")) == NULL )	{	printf("Write %s error!!\n", filename);	return;	}
			fwrite(q4_ArtCoeff, sizeof(unsigned char), ANGLE * CAMNUM * ART_COEF_2, fpt);
			fclose(fpt);
*/
			// save color descriptor to disk
			fwrite(CompactColor, sizeof(unsigned char), ANGLE * CAMNUM * sizeof(unsigned __int64), fpt4);
			sprintf(filename, "%s.ccd", fname);
			if( (fpt = fopen(filename, "wb")) == NULL )	{	printf("Write %s error!!\n", filename);	return;	}
			fwrite(CompactColor, sizeof(unsigned char), ANGLE * CAMNUM * sizeof(unsigned __int64), fpt);
			fclose(fpt);
		}

		for(i=0; i<CAMNUM; i++)
		{
			free(srcBuff[i]);
			free(ColorBuff[i]);
		}
		free(YuvBuff);
		free(EdgeBuff);
		fclose(fpt1);
//		fclose(fpt2);
//		fclose(fpt3);
		fclose(fpt4);
		for(destCam=0; destCam<ANGLE; destCam++)
		{
			free(CamVertex[destCam]);
			free(CamTriangle[destCam]);
		}
		NumTri = 0;
		break;

// *************************************************************************************************
	// calculate fourier feature only
/*	case 'f':
		// initialize: read camera set
		for(destCam=0; destCam<ANGLE; destCam++)
		{
			sprintf(filename, "12_%d", destCam);
			ReadObj(filename, CamVertex+destCam, CamTriangle+destCam, CamNumVer+destCam, CamNumTri+destCam);
		}

		for(i=0; i<CAMNUM; i++)
			srcBuff[i] = (unsigned char *) malloc (winw * winh * sizeof(unsigned char));
		fpt1 = fopen("list.txt", "r");
		fpt3 = fopen("all.fd", "wb");
		while( fgets(fname, 400, fpt1) )
		{
			// record execute time --- start
 			start = clock();

			fname[strlen(fname)-1] = 0x00;
			// get the translatation and scale of the two model
			if( ReadObj(fname, &vertex1, &triangle1, &NumVer1, &NumTri1) == 0 )
				continue;

			// Translate and scale model 1
			TranslateScale(vertex1, NumVer1, triangle1, NumTri1, fname, &Translate1, &Scale1);

			// read DEPTH only, so size is winw*winh
			for(srcCam=0; srcCam<ANGLE; srcCam++)
			{
				// capture CAMNUM silhouette of srcfn to memory
				for(i=0; i<CAMNUM; i++)
				{
					RenderToMem(srcBuff[i], NULL, CamVertex[srcCam]+i, vertex1, triangle1, NumVer1, NumTri1);
					FourierDescriptor(src_FdCoeff[srcCam][i], srcBuff[i], winw, winh);
				}
			}

			// free memory of 3D model
			free(vertex1);
			free(triangle1);

			// record execute time --- end
			finish = clock();

//fpt = fopen(filename, "wt");
//for(srcCam=0; srcCam<ANGLE; srcCam++)
//for(i=0; i<CAMNUM; i++)
//{
//	for(j=0; j<FD_COEFF_NO; j++)
//		fprintf(fpt, "%3f ", src_FdCoeff[srcCam][i][j]);
//	fprintf(fpt, "\n");
//}
			// save feature to file
			fwrite(src_FdCoeff, ANGLE * CAMNUM * FD_COEFF_NO, sizeof(double), fpt3);
			sprintf(filename, "%s.fd", fname);
			fpt = fopen(filename, "wb");
			fwrite(src_FdCoeff, ANGLE * CAMNUM * FD_COEFF_NO, sizeof(double), fpt);
			fclose(fpt);

			// record execute time --- end
			fpt = fopen("feature_time.txt", "a");
			fprintf(fpt, "%s ( V: %d T: %d )\t: %f sec;\n", fname, NumVer1, NumTri1, (double)(finish - start) / CLOCKS_PER_SEC );
			fclose(fpt);
		}

		for(i=0; i<CAMNUM; i++)
			free(srcBuff[i]);
		fclose(fpt1);
		fclose(fpt3);
		for(destCam=0; destCam<ANGLE; destCam++)
		{
			free(CamVertex[destCam]);
			free(CamTriangle[destCam]);
		}
		NumTri = 0;
		break;
*/
// *************************************************************************************************
	// compare one model to all other models (ART)
	case 'd':
		// initialize: read camera pair
		fpt = fopen("align20.txt", "r");
		for(i=0; i<60; i++)
			for(j=0; j<CAMNUM_2; j++)
				fscanf(fpt, "%d", &align[i][j]);
		fclose(fpt);

		// read filename of two models
		fpt1 = fopen("compare.txt", "r");
		if( fscanf(fpt1, "%s", srcfn) == EOF )
			break;
		fclose(fpt1);

		// read coefficient from model 1
		sprintf(filename, "%s_otho.art", srcfn);
		if( (fpt = fopen(filename, "rb")) == NULL )
		{
			printf("%s does not exist.\n", filename);
			break;
		}

/*		for(srcCam=0; srcCam<ANGLE; srcCam++)
			for(i=0; i<CAMNUM; i++)
				for(p=0 ; p<ART_ANGULAR ; p++)
					for(r=0 ; r<ART_RADIAL ; r++)
						fscanf(fpt, "%lf", &src_ArtCoeff[srcCam][i][p][r]);
*/
		fread(src_ArtCoeff, ANGLE * CAMNUM * ART_ANGULAR * ART_RADIAL, sizeof(double), fpt);
		fclose(fpt);

		// read feature of all models
		fpt1 = fopen("list.txt", "r");
		Count = 0;
		pSearch = NULL;
		while( fscanf(fpt1, "%s", destfn) != EOF )
		{
			// read coefficient from model 2
			sprintf(filename, "%s_otho.art", destfn);
			if( (fpt = fopen(filename, "rb")) == NULL )
			{
				printf("%s does not exist.\n", filename);
				break;
			}

/*			for(destCam=0; destCam<ANGLE; destCam++)
				for(i=0; i<CAMNUM; i++)
					for(p=0 ; p<ART_ANGULAR ; p++)
						for(r=0 ; r<ART_RADIAL ; r++)
							fscanf(fpt, "%lf", &dest_ArtCoeff[destCam][i][p][r]);
*/
			fread(dest_ArtCoeff, ANGLE * CAMNUM * ART_ANGULAR * ART_RADIAL, sizeof(double), fpt);
			fclose(fpt);

			// compare each coefficients pair from the two models first
			for(destCam=0; destCam<ANGLE; destCam++)
				for(i=0; i<CAMNUM_2; i++)
					for(srcCam=0; srcCam<ANGLE; srcCam++)
						for(j=0; j<CAMNUM_2; j++)
							cost[srcCam][destCam][j][i] = GetDistance(dest_ArtCoeff[destCam][CamMap[i]], src_ArtCoeff[srcCam][CamMap[j]]);

			// find minimum error of the two models from all camera pairs
			MinErr = DBL_MAX;
			for(srcCam=0; srcCam<ANGLE; srcCam++)		// each src angle
				for(destCam=0; destCam<ANGLE; destCam++)	// each dest angle
					for(i=0; i<60; i++)						// each align
					{
						err = 0;
						for(j=0; j<CAMNUM_2; j++)				// each vertex
							err += cost[srcCam][destCam][CamMap[j]][CamMap[align[i][j]]];

						if( err < MinErr )
							MinErr = err;
					}

//			printf("Difference of %s and %s: %f\n", srcfn, destfn, MinErr);
			// add to a list
			pmr = (pMatRes) malloc (sizeof(MatRes));
			strcpy(pmr->name, destfn);
			pmr->sim = MinErr;
			pmr->pointer = pSearch;
			pSearch = pmr;
			Count ++;
		}
		
		TopNum = 10;		// show top 10

		pTop = (pMatRes) malloc ( TopNum * sizeof(MatRes) );
		for(i=0; i<TopNum; i++)
		{
			pTop[i].sim = DBL_MAX;
			strcpy(pTop[i].name, "");
		}

		for(pmr=pSearch; pmr; pmr=pmr->pointer)
			for(i=0; i<TopNum; i++)
				if( pmr->sim < pTop[i].sim )
				{
					for(j=TopNum-2; j>=i; j--)
					{
						strcpy(pTop[j+1].name, pTop[j].name);
						pTop[j+1].sim = pTop[j].sim;
					}
					strcpy(pTop[i].name, pmr->name);
					pTop[i].sim = pmr->sim;
					break;
				}

		printf("%s\n", srcfn);
		for(i=0; i<TopNum && i<Count; i++)
			printf("%s %.6f\n", pTop[i].name, pTop[i].sim);
		printf("\n");

		pmr=pSearch;
		while(pmr)
		{
			pmrr = pmr;
			pmr = pmr->pointer;
			free(pmrr);
		}
		free(pTop);

		break;

// *************************************************************************************************
	// compare one model to all other models using color
	case 'x':
		// initialize: read camera pair