NURBS Curveback Reimbursing Deforming Function Call Model Code 1 (OCC Import Export)

The code shows how to use API to complete the NURBS curve to compensate for the deformation. The code contains the original curvature data and the curve data to export the new variant using the OCC function.

The code that follows is as follows:

Resurflib part:

ResurfFitIO.dll

ResurfNurbsLib.dll

ResurfSurfmap.dll

OCC section：

TKernel.dll
TKMath.dll
TKG2d.dll
TKG3d.dll
TKGeomBase.dll
TKBRep.dll
TKGeomAlgo.dll
TKTopAlgo.dll
TKShHealing.dll
TKXSBase.dll
TKPrim.dll
TKBool.dll
TKBO.dll
TKIGES.dll
TKSTEPBase.dll
TKSTEPAttr.dll
TKSTEP209.dll
TKSTEP.dll

Operating environment component:

tbb.dll
tbbmalloc.dll

tbb12.dll

MSVCP140.dll
VCRUNTIME140.dll


#include<stdio.h>
#include<stdlib.h>
#include"malloc.h"
#pragma comment(lib,"ResurfFitIO.lib") 
#pragma comment(lib,"ResurfNurbsLib.lib") 
#pragma comment(lib,"ResurfSurfmap.lib") 
#include "surffrommesh.h"  
#include "resurffillhole.h"  
#include "resurfsurfacemapping.h"
#include "surfmap_resurflicensekey.h"
#include "resurffitio.h"  
void testSurfacemapByNurbsApiOccIgs()
{
	char output[1024];	TCHAR current_dir[MAX_PATH];
	if (GetCurrentDirectory(MAX_PATH, current_dir))
	{
	}
	else
	{
		printf("Failed to find current directory\n");
		return;
	}
	char cdir[MAX_PATH];
	WideCharToMultiByte(CP_ACP, 0, current_dir, -1, cdir, MAX_PATH, NULL, NULL);
	Sprintf (output, "%s\surface map result occ.igsZXENTTY1XZ, cdir); // or import step: sprintf (output, "%s\surface map result occ.stpZXENTTY3XZ, cdir);
	char tx_origmesh_stl[1024];
	char tx_newmesh_stl[1024];
	char tx_orgnurbs_igs[1024];
	sprintf(tx_origmesh_stl, "%s\\data_surfmap_occ_igs\\original.stl", cdir);
	sprintf(tx_newmesh_stl, "%s\\data_surfmap_occ_igs\\morph.stl", cdir);
	sprintf(tx_orgnurbs_igs, "%s\\data_surfmap_occ_igs\\original.igs", cdir);
	printf (" start of calculation.\nZXENTTY1XZ);
	surfmap_start();
	if (surfmap_import_origstl(tx_origmesh_stl))
	{
		if (surfmap_import_tragetstl(tx_newmesh_stl))
		{
			printf (" reads the grid successfully.\n");
			std: :vector ZXENTYXRRsNurbSurfaceVZXENTITY1XnZnurbs; ///original
			std: :vectorZXENTTYXZRsNurbCurveV>nurbc;/ /igs surface data, not needed, not available
			std:: vector ZXENTTY0XRRsNurbSurfaceV>nbs;// /conforming new curves
			// Use OOCC to import surface data onigs, which will not be used
			If (ImportOCCIGsCrvSrf (tx orgnurbs igs, turbc, turbs))//(ImportOCCStepCrvSrf (tx orgnurbs igs, urbc, nerbs))
			{
				printf (" reads original side successfully.\n");
				for (size_t i = 0; i < nurbs.size(); ++i)
				{
					surfmap_AppendNurbsData(nurbs[i].xCpoint.data(), nurbs[i].yCpoint.data(), nurbs[i].zCpoint.data(),
						nurbs[i].weight.data(), nurbs[i].u_num, nurbs[i].v_num, nurbs[i].isrational,
						nurbs[i].u_degree, nurbs[i].v_degree, nurbs[i].u_knot.data(), nurbs[i].v_knot.data());
					If (nurbs[i].loopcurves.size() ZXENTTY0XZ0)//cut Ring
					{
						for (size_t j = 0; j < nurbs[i].loopcurves.size(); ++j)
						{
							Surfmap Append2DLoop start(); //start with this cut Ring
							for (size_t k = 0; k < nurbs[i].loopcurves[j].size(); ++k)
							{
								//Put this cropring with a 2D crop curve
								surfmap_Append2DNurbCurveInLoop(nurbs[i].loopcurves[j][k].xcpt.data(),
									nurbs[i].loopcurves[j][k].ycpt.data(),
									nurbs[i].loopcurves[j][k].weight.data(),
									nurbs[i].loopcurves[j][k].n,
									nurbs[i].loopcurves[j][k].isrational,
									nurbs[i].loopcurves[j][k].degree,
									nurbs[i].loopcurves[j][k].knot.data());
							}
						}
						Surfmap Append2DLoop end();//all clippings have been added, over
					}
				}
				surfmap_setFeed(1.0);
				printf (" begins to deform...\n");
				if (surfmap_domap())
				{
					printf (" starts exporting new curves...\n");
					Int facecount = surfmap GetNewfacecount(); /// Number of curves successfully deformed
					if (facecount <= 0)
					{
						surfmap_end(); return;
					}
					nbs.resize(facecount);
					for (int ni = 0; ni < facecount; ++ni)
					{
						int unum = 0, vnum = 0, ud = 0, vd = 0;
						double* uknot = NULL, * vknot = NULL, * xc = NULL, * yc = NULL, * zc = NULL;
						//Retrieving data on a new curve
						surfmap_GetNurbs(ni, &unum, &vnum, &ud, &vd, &uknot, &vknot, &xc, &yc, &zc);
						int size = unum * vnum;
						for (int i = 0; i < size; ++i)
						{
							nbs[ni].xCpoint.push_back(xc[i]);
							nbs[ni].yCpoint.push_back(yc[i]);
							nbs[ni].zCpoint.push_back(zc[i]);
						}
						for (int i = 0; i < (unum + ud + 1); ++i)
						{
							nbs[ni].u_knot.push_back(uknot[i]);
						}
						for (int i = 0; i < (vnum + vd + 1); ++i)
						{
							nbs[ni].v_knot.push_back(vknot[i]);
						}
						nbs[ni].u_num = unum; nbs[ni].v_num = vnum;
						nbs[ni].u_degree = ud; nbs[ni].v_degree = vd;
						nbs[ni].u_start = uknot[ud]; nbs[ni].u_end = uknot[unum];
						nbs[ni].v_start = vknot[vd]; nbs[ni].v_end = vknot[vnum];
						nbs[ni].isrational = 0;
						surfmap_ResurfLibFreeMemory(uknot);
						surfmap_ResurfLibFreeMemory(vknot);
						surfmap_ResurfLibFreeMemory(xc);
						surfmap_ResurfLibFreeMemory(yc);
						surfmap_ResurfLibFreeMemory(zc);
						/ How many tailors for this new side Ring
						int loopcount = surfmap_GetLoopCount(ni);
						if (loopcount <= 0) continue;
						nbs[ni].loopcurves.resize(loopcount);
						for (int j = 0; j < loopcount; ++j)
						{
							/ / j cropring how many 2d crop surface data
							int curvecount = surfmap_Get2DTrimmingCurveCount(ni, j);
							nbs[ni].loopcurves[j].resize(curvecount);
							for (int k = 0; k < curvecount; ++k)
							{
								int ctrlp_num = 0;
								int degree = 3;
								double* knot = NULL, * cpx = NULL, * cpy = NULL;
								//Retrieving article k2d of j shearring
								surfmap_Get2DTrimmingCurve(ni, j, k, &ctrlp_num, &degree, &knot, &cpx, &cpy);
								for (int ki = 0; ki < ctrlp_num; ++ki)
								{
									nbs[ni].loopcurves[j][k].xcpt.push_back(cpx[ki]);
									nbs[ni].loopcurves[j][k].ycpt.push_back(cpy[ki]);
									nbs[ni].loopcurves[j][k].zcpt.push_back(0);
								}
								for (int ki = 0; ki < (ctrlp_num + degree + 1); ++ki)
								{
									nbs[ni].loopcurves[j][k].knot.push_back(knot[ki]);
								}
								nbs[ni].loopcurves[j][k].n = ctrlp_num;
								nbs[ni].loopcurves[j][k].degree = degree;
								nbs[ni].loopcurves[j][k].isrational = 0;
								nbs[ni].loopcurves[j][k].start = knot[degree];
								nbs[ni].loopcurves[j][k].end = knot[ctrlp_num];
								surfmap_ResurfLibFreeMemory(knot);
								surfmap_ResurfLibFreeMemory(cpx);
								surfmap_ResurfLibFreeMemory(cpy);
							}
						}
					}
					ExportOCCIgsCrvSrf (output, turbc, nbs);///use OCC to export new curve data, curbc data can not be available; step replace ExportOCC StepCrvSrf (output, nurbc, nbs);
				}
			}
		}
	}
	surfmap_end();
	printf (" end of calculation.\nZXENTTY1XZ);
	getchar();
}