main.c

完整的3D 模型检索程序

			// refine Translate and scale between model 1 and 2
			TranslateScale(vertex2, NumVer2, destfn, &Translate2, &Scale2);
			TranslateScale(vertex1, NumVer1, srcfn, &Translate1, &Scale1);

			// refine rotate of model 2 to fit the model 1
			Err = Refine(src_ArtCoeff[UseCam], vertex2, triangle2, NumVer2, NumTri2, UseCam,
						 CamVertex[UseCam], CamTriangle[UseCam], CamNumVer[UseCam], CamNumTri[UseCam]);

			// refine Translate and scale of model 2 again
			TranslateScale(vertex2, NumVer2, destfn, &Translate2, &Scale2);

			// scale and translate back to the original state of model 1
			Scale1 = 1.0 / Scale1;
			Scale(vertex2, NumVer2, Scale1);

			Translate1.coor[0] = -Translate1.coor[0];
			Translate1.coor[1] = -Translate1.coor[1];
			Translate1.coor[2] = -Translate1.coor[2];
			Translate(vertex2, NumVer2, Translate1);

			// record execute time --- end
			finish = clock();
			fpt = fopen("time.txt", "a");
			fprintf(fpt, " Refine %.1f sec.\n", (double)(finish - start) / CLOCKS_PER_SEC );
			fclose(fpt);

			sprintf(filename, "%s_to_%s_refine.obj", destfn, srcfn);
			SaveObj(filename, vertex2, triangle2, NumVer2, NumTri2);

			// save two model
			// model 1 should translate and scale back to original
			Scale(vertex1, NumVer1, Scale1);
			Translate(vertex1, NumVer1, Translate1);
			sprintf(filename, "%s_to_%s_merge_refine.obj", destfn, srcfn);
			SaveMergeObj(filename, vertex1, triangle1, NumVer1, NumTri1, vertex2, triangle2, NumVer2, NumTri2);

			// write Err to file
			fpt2 = fopen("Refine_Err.txt", "a");
			fprintf(fpt2, "Err of %s to %s : %f\n", destfn, srcfn, Err);
			fclose(fpt2);

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

		fclose(fpt1);
		for(destCam=0; destCam<ANGLE; destCam++)
		{
			free(CamVertex[destCam]);
			free(CamTriangle[destCam]);
		}
		NumTri = 0;
		break;
*/
// *************************************************************************************************
	// calculate feature and save to file
	case 'n':
		// initialize ART
		GenerateBasisLUT();
		// 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));
			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));

		// for Fourier Descriptor
		total = winw * winh;
		Contour = (sPOINT *) malloc( total * sizeof(sPOINT));
		ContourMask = (unsigned char *) malloc( total * sizeof(unsigned char));

		fpt1 = fopen("list.txt", "r");
		fpt_art_q4 = fopen("all_q4_v1.8.art", "wb");
		fpt_art_q8 = fopen("all_q8_v1.8.art", "wb");
//		fpt_ccd = fopen("all_v1.7.ccd", "wb");
		fpt_cir_q8 = fopen("all_q8_v1.8.cir", "wb");
//		fpt_fd = fopen("all.fd", "wb");
		fpt_fd_q8 = fopen("all_q8_v1.8.fd", "wb");
		fpt_ecc_q8 = fopen("all_q8_v1.8.ecc", "wb");
		Count = 0;
		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);
					RenderToMem(srcBuff[i], NULL, CamVertex[srcCam]+i, vertex1, triangle1, NumVer1, NumTri1);

				// find center for each shape
				for(i=0; i<CAMNUM; i++)
					FindCenter(srcBuff[i], winw, winh, CenX+i, CenY+i);

				// 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], winw, winh);
//					ExtractCCD(YuvBuff, CompactColor[srcCam]+i, srcBuff[i]);
					// 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");
//				}

				// get Zernike moment
				FindRadius(srcBuff, CenX, CenY);
				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, CenX[i], CenY[i]);
				}

				// get Fourier descriptor
				for(i=0; i<CAMNUM; i++)
					FourierDescriptor(src_FdCoeff[srcCam][i], srcBuff[i], winw, winh, Contour, ContourMask, CenX[i], CenY[i]);

				// get eccentricity
				for(i=0; i<CAMNUM; i++)
					ecc_Coeff[srcCam][i] = Eccentricity(srcBuff[i], winw, winh, CenX[i], CenY[i]);

				// get circularity
				for(i=0; i<CAMNUM; i++)
				{
					EdgeDetectSil(EdgeBuff, srcBuff[i], winw, winh);
					cir_Coeff[srcCam][i] = Circularity(srcBuff[i], winw, winh, 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 ART feature to file
//			sprintf(filename, "%s_v1.7.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++)
				{
					// the order is the same with that defined in MPEG-7, total 35 coefficients
					k = 0;
					p = 0;
					for(r=1 ; r<ART_RADIAL ; r++, k++)
					{
						itmp = (int)(QUANT8 *  src_ArtCoeff[i][j][p][r]);
						if(itmp>255)
							q8_ArtCoeff[i][j][k] = 255;
						else
							q8_ArtCoeff[i][j][k] = itmp;
					}

					for(p=1; p<ART_ANGULAR ; p++)
						for(r=0 ; r<ART_RADIAL ; r++, k++)
						{
							itmp = (int)(QUANT8 *  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, fpt_art_q8);
			sprintf(filename, "%s_q8_v1.8.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++)
				{
					// the order is the same with that defined in MPEG-7, total 35 coefficients
					k = 0;
					p = 0;
					for(r=1 ; r<ART_RADIAL ; r++, k++)
					{
						high = 17;
						low = 0;
						while(high-low > 1)
						{
							middle = (high+low) / 2;

							if(QuantTable[middle] < src_ArtCoeff[i][j][p][r])
								low = middle;
							else
								high = middle;
						}
						q8_ArtCoeff[i][j][k] = low;
					}
					for(p=1; p<ART_ANGULAR ; p++)
						for(r=0 ; r<ART_RADIAL ; r++, k++)
						{
							high = 17;
							low = 0;
							while(high-low > 1)
							{
								middle = (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++)
						if( k+1 < ART_COEF )
							q4_ArtCoeff[i][j][a] = ( (q8_ArtCoeff[i][j][k] << 4) & 0xf0 ) | 
												( q8_ArtCoeff[i][j][k+1] & 0x0f );
						else
							q4_ArtCoeff[i][j][a] = ( (q8_ArtCoeff[i][j][k] << 4) & 0xf0 );

			// save to disk
			fwrite(q4_ArtCoeff, sizeof(unsigned char), ANGLE * CAMNUM * ART_COEF_2, fpt_art_q4);
			sprintf(filename, "%s_q4_v1.8.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), fpt_ccd);
//			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);

			// **********************************************************************
			// save circularity feature to file
//			sprintf(filename, "%s.cir", fname);
//			fpt = fopen(filename, "wb");
//			fwrite(cir_Coeff, ANGLE * CAMNUM, 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++)
				{
					itmp = (int)(QUANT8 *  cir_Coeff[i][j]);
					if(itmp>255)		q8_cirCoeff[i][j] = 255;
					else				q8_cirCoeff[i][j] = itmp;
				}
			// save to disk
			fwrite(q8_cirCoeff, sizeof(unsigned char), ANGLE * CAMNUM, fpt_cir_q8);
			sprintf(filename, "%s_q8_v1.8.cir", fname);
			if( (fpt = fopen(filename, "wb")) == NULL )	{	printf("Write %s error!!\n", filename);	return;	}
			fwrite(q8_cirCoeff, sizeof(unsigned char), ANGLE * CAMNUM, fpt);
			fclose(fpt);

			// **********************************************************************
			// save eccentricity feature to file
			// linear Quantization to 8 bits for each coefficient
			for(i=0; i<ANGLE; i++)
				for(j=0; j<CAMNUM; j++)
				{
					itmp = (int)(QUANT8 * ecc_Coeff[i][j]);
					if(itmp>255)		q8_eccCoeff[i][j] = 255;
					else				q8_eccCoeff[i][j] = itmp;
				}
			// save to disk
			fwrite(q8_eccCoeff, sizeof(unsigned char), ANGLE * CAMNUM, fpt_ecc_q8);
			sprintf(filename, "%s_q8_v1.8.ecc", fname);
			if( (fpt = fopen(filename, "wb")) == NULL )	{	printf("Write %s error!!\n", filename);	return;	}
			fwrite(q8_eccCoeff, sizeof(unsigned char), ANGLE * CAMNUM, fpt);
			fclose(fpt);

			// **********************************************************************
			// save Fourier descriptor feature to file
//			fwrite(src_FdCoeff, ANGLE * CAMNUM * FD_COEFF_NO, sizeof(double), fpt_fd);
//			sprintf(filename, "%s.fd", fname);
//			fpt = fopen(filename, "wb");
//			fwrite(src_FdCoeff, ANGLE * CAMNUM * FD_COEFF_NO, sizeof(double), fpt);
//			fclose(fpt);

			for(i=0; i<ANGLE; i++)
				for(j=0; j<CAMNUM; j++)
				{
					for(k=0; k<FD_COEFF_NO; k++)
					{
						itmp = (int)(QUANT8 * FD_SCALE * src_FdCoeff[i][j][k]);
						if(itmp>255)
							q8_FdCoeff[i][j][k] = 255;
						else
							q8_FdCoeff[i][j][k] = itmp;
					}
				}

			fwrite(q8_FdCoeff, ANGLE * CAMNUM * FD_COEFF_NO, sizeof(unsigned char), fpt_fd_q8);
			sprintf(filename, "%s_q8_v1.8.fd", fname);
			fpt = fopen(filename, "wb");
			fwrite(q8_FdCoeff, ANGLE * CAMNUM * FD_COEFF_NO, sizeof(unsigned char), fpt);
			fclose(fpt);

//			printf("%d.%s OK.\n", Count++, fname);
			printf("%d.", Count++);
		}

		for(i=0; i<CAMNUM; i++)
		{
			free(srcBuff[i]);
			free(ColorBuff[i]);
		}
		free(YuvBuff);
		free(EdgeBuff);
		free(Contour);
		free(ContourMask);
		fclose(fpt1);
		fclose(fpt_art_q8);
		fclose(fpt_art_q4);
//		fclose(fpt_ccd);
		fclose(fpt_cir_q8);
		fclose(fpt_ecc_q8);
//		fclose(fpt_fd);
		fclose(fpt_fd_q8);
		for(destCam=0; destCam<ANGLE; destCam++)
		{
			free(CamVertex[destCam]);
			free(CamTriangle[destCam]);
		}
		NumTri = 0;
		break;

// *************************************************************************************************
	// calculate color feature only
	case 'm':
		// initialize ART
//		GenerateBasisLUT();
		// initialize: read camera set