AcDbIntArray & geomIds) const
#else
Acad::ErrorStatus PDSphere::getOsnapPoints(
AcDb::OsnapMode osnapMode,
int gsSelectionMark,
const AcGePoint3d& pickPoint,
const AcGePoint3d& lastPoint,
const AcGeMatrix3d& viewXform,
AcGePoint3dArray& snapPoints,
AcDbIntArray& geomIds) const
#endif
{
assertReadEnabled();
if(!hasSnap())
return Acad::eOk;
if(gsSelectionMark == 0)
return Acad::eOk;
AcGeVector3d viewDir(viewXform(Z, 0), viewXform(Z, 1),
viewXform(Z, 2));
switch(osnapMode)
{
case AcDb::kOsModeEnd:
break;
case AcDb::kOsModeMid:
break;
case AcDb::kOsModeCen:
snapPoints.append(m_ptCenter);
break;
case AcDb::kOsModeQuad:
{
AcGeCubicSplineCurve3d varcur;
AcGeCubicSplineCurve3d varcurs[7];
switch(gsSelectionMark)
{
case 1:
varcur = AcGeCubicSplineCurve3d(AcGeCircArc3d(m_ptCenter, AcGeVector3d(1, 0, 0), m_dRadius));
break;
case 2:
varcur = AcGeCubicSplineCurve3d(AcGeCircArc3d(m_ptCenter, AcGeVector3d(1, 1, 0), m_dRadius));
break;
case 3:
varcur = AcGeCubicSplineCurve3d(AcGeCircArc3d(m_ptCenter, AcGeVector3d(0, 1, 0), m_dRadius));
break;
case 4:
varcur = AcGeCubicSplineCurve3d(AcGeCircArc3d(m_ptCenter, AcGeVector3d(-1, 1, 0), m_dRadius));
break;
case 5:
varcur = AcGeCubicSplineCurve3d(AcGeCircArc3d(m_ptCenter, AcGeVector3d(0, 0, 1), m_dRadius));
break;
case 6:
varcur = AcGeCubicSplineCurve3d(AcGeCircArc3d(m_ptCenter - AcGeVector3d(0, 0, 1) * m_dRadius * cos(PI / 4.0), AcGeVector3d(0, 0, 1), m_dRadius * sin(PI / 4.0)));
break;
case 7:
varcur = AcGeCubicSplineCurve3d(AcGeCircArc3d(m_ptCenter + AcGeVector3d(0, 0, 1) * m_dRadius * cos(PI / 4.0), AcGeVector3d(0, 0, 1), m_dRadius * sin(PI / 4.0)));
break;
//定义球面象限点的捕捉方式
//added by szw 2009.11.18 : begin
case 8:
varcurs[0] = AcGeCubicSplineCurve3d(AcGeCircArc3d(m_ptCenter, AcGeVector3d(1, 0, 0), m_dRadius));
varcurs[1] = AcGeCubicSplineCurve3d(AcGeCircArc3d(m_ptCenter, AcGeVector3d(1, 1, 0), m_dRadius));
varcurs[2] = AcGeCubicSplineCurve3d(AcGeCircArc3d(m_ptCenter, AcGeVector3d(0, 1, 0), m_dRadius));
varcurs[3] = AcGeCubicSplineCurve3d(AcGeCircArc3d(m_ptCenter, AcGeVector3d(-1, 1, 0), m_dRadius));
varcurs[4] = AcGeCubicSplineCurve3d(AcGeCircArc3d(m_ptCenter, AcGeVector3d(0, 0, 1), m_dRadius));
varcurs[5] = AcGeCubicSplineCurve3d(AcGeCircArc3d(m_ptCenter - AcGeVector3d(0, 0, 1) * m_dRadius * cos(PI / 4.0), AcGeVector3d(0, 0, 1), m_dRadius * sin(PI / 4.0)));
varcurs[6] = AcGeCubicSplineCurve3d(AcGeCircArc3d(m_ptCenter + AcGeVector3d(0, 0, 1) * m_dRadius * cos(PI / 4.0), AcGeVector3d(0, 0, 1), m_dRadius * sin(PI / 4.0)));
break;
default:
break;
//added by szw 2009.11.18 : end
}
if(gsSelectionMark < 8)
{
double fromParam = varcur.startParam();
double toParam = varcur.endParam();
double delta = (toParam - fromParam) / 4.0;
for(int i = 0; i < 4; i++)
snapPoints.append(varcur.evalPoint(fromParam + i * delta));
}
//定义球面象限点的捕捉方式
//added by szw 2009.11.18 : begin
else if(gsSelectionMark == 8)
{
for(int j = 0; j < 7; ++j)
{
double fromParam = varcurs[j].startParam();
double toParam = varcurs[j].endParam();
double delta = (toParam - fromParam) / 4.0;
for(int i = 0; i < 4; i++)
snapPoints.append(varcurs[j].evalPoint(fromParam + i * delta));
}
}
//added by szw 2009.11.18 : end
}
break;
case AcDb::kOsModeNode:
break;
case AcDb::kOsModeIns:
snapPoints.append(m_ptCenter);
break;
case AcDb::kOsModePerp:
{
AcGeCircArc3d cir;
AcGeCircArc3d cirs[7];
switch(gsSelectionMark)
{
case 1:
cir.set(m_ptCenter, AcGeVector3d(1, 0, 0), m_dRadius);
break;
case 2:
cir.set(m_ptCenter, AcGeVector3d(1, 1, 0), m_dRadius);
break;
case 3:
cir.set(m_ptCenter, AcGeVector3d(0, 1, 0), m_dRadius);
break;
case 4:
cir.set(m_ptCenter, AcGeVector3d(-1, 1, 0), m_dRadius);
break;
case 5:
cir.set(m_ptCenter, AcGeVector3d(0, 0, 1), m_dRadius);
break;
case 6:
cir.set(m_ptCenter - AcGeVector3d(0, 0, 1) * m_dRadius * cos(PI / 4.0), AcGeVector3d(0, 0, 1), m_dRadius *sin(PI / 4.0));
break;
case 7:
cir.set(m_ptCenter + AcGeVector3d(0, 0, 1) * m_dRadius * cos(PI / 4.0), AcGeVector3d(0, 0, 1), m_dRadius * sin(PI / 4.0));
break;
//定义球面垂直正交点的捕捉方式
//added by szw 2009.11.18 : begin
case 8:
cirs[0].set(m_ptCenter, AcGeVector3d(1, 0, 0), m_dRadius);
cirs[1].set(m_ptCenter, AcGeVector3d(1, 1, 0), m_dRadius);
cirs[2].set(m_ptCenter, AcGeVector3d(0, 1, 0), m_dRadius);
cirs[3].set(m_ptCenter, AcGeVector3d(-1, 1, 0), m_dRadius);
cirs[4].set(m_ptCenter, AcGeVector3d(0, 0, 1), m_dRadius);
cirs[5].set(m_ptCenter - AcGeVector3d(0, 0, 1) * m_dRadius * cos(PI / 4.0), AcGeVector3d(0, 0, 1), m_dRadius *sin(PI / 4.0));
cirs[6].set(m_ptCenter + AcGeVector3d(0, 0, 1) * m_dRadius * cos(PI / 4.0), AcGeVector3d(0, 0, 1), m_dRadius * sin(PI / 4.0));
break;
default:
break;
//added by szw 2009.11.18 : end
}
if(gsSelectionMark < 8)
{
AcGePoint3d pt;
pt = cir.closestPointTo(lastPoint);
snapPoints.append(pt);
}
//定义球面垂直正交点的捕捉方式
//added by szw 2009.11.18 : begin
else if(gsSelectionMark == 8)
{
for(int i = 0; i < 7; ++i)
{
AcGePoint3d pt;
pt = cirs[i].closestPointTo(lastPoint);
snapPoints.append(pt);
}
}
//added by szw 2009.11.18 : end
}
break;
case AcDb::kOsModeTan:
break;
case AcDb::kOsModeNear:
{
AcGePoint3d pt;
AcGeCircArc3d cir;
AcGeCircArc3d cirs[7];
switch(gsSelectionMark)
{
case 1:
cir.set(m_ptCenter, AcGeVector3d(1, 0, 0), m_dRadius);
break;
case 2:
cir.set(m_ptCenter, AcGeVector3d(1, 1, 0), m_dRadius);
break;
case 3:
cir.set(m_ptCenter, AcGeVector3d(0, 1, 0), m_dRadius);
break;
case 4:
cir.set(m_ptCenter, AcGeVector3d(-1, 1, 0), m_dRadius);
break;
case 5:
cir.set(m_ptCenter, AcGeVector3d(0, 0, 1), m_dRadius);
break;
case 6:
cir.set(m_ptCenter - AcGeVector3d(0, 0, 1) * m_dRadius * cos(PI / 4.0), AcGeVector3d(0, 0, 1), m_dRadius *sin(PI / 4.0));
break;
case 7:
cir.set(m_ptCenter + AcGeVector3d(0, 0, 1) * m_dRadius * cos(PI / 4.0), AcGeVector3d(0, 0, 1), m_dRadius * sin(PI / 4.0));
break;
//定义球面垂直正交点的捕捉方式
//added by szw 2009.11.18 : begin
case 8:
cirs[0].set(m_ptCenter, AcGeVector3d(1, 0, 0), m_dRadius);
cirs[1].set(m_ptCenter, AcGeVector3d(1, 1, 0), m_dRadius);
cirs[2].set(m_ptCenter, AcGeVector3d(0, 1, 0), m_dRadius);
cirs[3].set(m_ptCenter, AcGeVector3d(-1, 1, 0), m_dRadius);
cirs[4].set(m_ptCenter, AcGeVector3d(0, 0, 1), m_dRadius);
cirs[5].set(m_ptCenter - AcGeVector3d(0, 0, 1) * m_dRadius * cos(PI / 4.0), AcGeVector3d(0, 0, 1), m_dRadius *sin(PI / 4.0));
cirs[6].set(m_ptCenter + AcGeVector3d(0, 0, 1) * m_dRadius * cos(PI / 4.0), AcGeVector3d(0, 0, 1), m_dRadius * sin(PI / 4.0));
break;
default:
break;
//added by szw 2009.11.18 : end
}
if(gsSelectionMark < 8)
{
pt = cir.projClosestPointTo(pickPoint, viewDir);
snapPoints.append(pt);
}
//定义球面垂直正交点的捕捉方式
//added by szw 2009.11.18 : begin
else if(gsSelectionMark == 8)
{
for(int i = 0; i < 7; ++i)
{
pt = cirs[i].projClosestPointTo(pickPoint, viewDir);
snapPoints.append(pt);
}
}
//added by szw 2009.11.18 : end
}
break;
default:
break;
}
return Acad::eOk;
}
float OrthographicCamera::generateRay(const Sample& sample,
RayDifferential* ray) const {
float invXRes = mFilm->getInvXResolution();
float invYRes = mFilm->getInvYResolution();
float xNDC = +2.0f * sample.imageX * invXRes - 1.0f;
float yNDC = -2.0f * sample.imageY * invYRes + 1.0f;
float dxNDC = +2.0f * (sample.imageX + 1.0f) * invXRes - 1.0f;
float dyNDC = -2.0f * (sample.imageY + 1.0f) * invYRes + 1.0f;
// from NDC space to view space
float xView = 0.5f * mFilmWidth * xNDC;
float yView = 0.5f * mFilmHeight * yNDC;
float dxView = 0.5f * mFilmWidth * dxNDC;
float dyView = 0.5f * mFilmHeight * dyNDC;
Vector3 pView(xView, yView, 0.0f);
Vector3 pDxView(dxView, yView, 0.0f);
Vector3 pDyView(xView, dyView, 0.0f);
Vector3 viewDir(0.0f, 0.0f, 1.0f);
// view space to world space
ray->o = mPosition + mOrientation * pView;
ray->dxOrigin = mPosition + mOrientation * pDxView;
ray->dyOrigin = mPosition + mOrientation * pDyView;
ray->d = ray->dxDir = ray->dyDir = mOrientation * viewDir;
ray->mint = 0.0f;
ray->maxt = INFINITY;
ray->depth = 0;
ray->hasDifferential = true;
return 1.0f;
}
void DecoScene::PointScreen2WorldRay(const vector2& pt, vector3& outOrigin, vector3& outDir) const
{
vector3 viewVec = PointScreen2Camera(pt);
matrix44 invview;
RI->GetTransform(TT_WorldToCamera, invview);
invview.invert();
if (camera->isOrthogonal())
{
vector4 viewOrigin(viewVec);
viewOrigin.z = 0.f;
vector4 viewDir(0, 0, -1, 0);
viewOrigin.w = 1.f;
viewOrigin = invview * vector4(viewOrigin);
vector4 worldVec = invview * viewDir;
outOrigin = vector3(viewOrigin.x, viewOrigin.y, viewOrigin.z);
outDir = vector3(worldVec.x, worldVec.y, worldVec.z);
}
else
{
viewVec.normalize();
outOrigin = camera->getEye();
vector4 worldVec = invview * vector4(viewVec);
outDir = vector3(worldVec.x, worldVec.y, worldVec.z);
}
}
void
Camera::drawGL()
{
// set up the screen with our camera parameters
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(fov(), g_image->width() / (float)g_image->height(), 0.01, 10000);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
Vector3 vCenter = eye() + viewDir();
gluLookAt(eye().x, eye().y, eye().z,
vCenter.x, vCenter.y, vCenter.z,
up().x, up().y, up().z);
}
DecoColor Shading(const vector3& realIntersectPt, const vector3& norm, const vector3& lightPos, const vector3& viewPos,
const vector3& lightDiffuse, const vector3& lightSpecular, const vector3& lightAmbient,
const vector3& matDiffuse, const vector3& matSpecular, const vector3&matAmbient)
{
vector3 col(0, 0, 0);
vector3 rayDir(lightPos - realIntersectPt);
vector3 viewDir(viewPos - realIntersectPt);
vector3 normal = norm;
viewDir.normalize();
rayDir.normalize();
normal.normalize();
vector3 halfDir = (viewDir + rayDir) / 2;
halfDir.normalize();
col += vector3(lightDiffuse.x * matDiffuse.x, lightDiffuse.y * matDiffuse.y, lightDiffuse.z * matDiffuse.z) * max(0.0, DotProduct(normal, rayDir));
//col += vector3(lightAmbient.x * matAmbient.x, lightAmbient.y * matAmbient.y, lightAmbient.z * matAmbient.z);
DOUBLE dotHalfAngle = max(0.0, DotProduct(halfDir, normal));
col += vector3(lightSpecular.x * matSpecular.x, lightSpecular.y * matSpecular.y, lightSpecular.z * matSpecular.z) * dotHalfAngle * dotHalfAngle;
return DecoColor(vector4(col.x, col.y, col.z, 1));
}
int viewresults(void)
{
int k,kmenu;
void * pscr = NULL;
shortstr newname;
int dirStat=checkDir("results");
if(dirStat==0){messanykey(10,15,"directory RESULTS is empty"); return 1;}
kmenu = 1;
label_1:
menu1(10,10,"","\010"
" View "
" Delete "
" Rename ","s_res",&pscr,&kmenu);
switch (kmenu)
{
case 0:
return 0;
case 1:
viewDir("results");
break;
case 2:
if(dirStat==2)
{ char mess[]="Can not clean dir 'results' because it contains the LOCK file";
if(blind) { printf("%s\n",mess); sortie(102);}
else { messanykey(3,13,mess); break;}
}
if ( mess_y_n( 6,13," Delete files ") )
{ struct dirent **namelist;
int n,i;
n = scandir("./results", &namelist, NULL, NULL);
for(i=0; i<n;i++)
{
char buff[100];
if(strcmp(namelist[i]->d_name,"aux") && strcmp(namelist[i]->d_name,"..") && strcmp(namelist[i]->d_name,".") )
{
sprintf(buff,"rm -rf results/%s",namelist[i]->d_name);
if(unlink(buff+7)) system(buff);
}
}
free(namelist);
}
put_text(&pscr);
return 1;
case 3:
strcpy(newname," ");
while(1)
{ void * pscr3;
get_text(1,maxRow(),maxCol(),maxRow(),&pscr3);
goto_xy(1,maxRow());
print("Enter new name: ");
k = str_redact(newname,1,30);
if (k == KB_ESC)
{ goto_xy(1,24);
clr_eol();
goto label_1;
}
if (k == KB_ENTER)
{
trim(newname);
if(rename("results",newname)==0)
{ char command[200];
mkdir("results",0755);
sprintf(command," cp -rp %s/aux results",newname);
system(command);
put_text(&pscr);
put_text(&pscr3);
return 1;
}
else messanykey(10,15," Can't rename the directory");
}
put_text(&pscr3);
}
}
goto label_1;
}
void GLLineIlluminator::enableLighting(GLContextData& contextData) const
{
/* Get a pointer to the context data item: */
DataItem* dataItem=contextData.retrieveDataItem<DataItem>(this);
/* Update the material texture if it is outdated: */
if(dataItem->materialVersion!=materialVersion)
updateMaterial(dataItem);
GLenum previousMatrixMode=glGet<GLint>(GL_MATRIX_MODE);
Geometry::Matrix<GLfloat,4,4> modelView;
if(autoViewDirection||autoLightDirection)
{
/* Get the modelview matrix from OpenGL: */
GLfloat matrixArray[16];
glGetFloatv(GL_MODELVIEW_MATRIX,matrixArray);
modelView=Geometry::Matrix<GLfloat,4,4>::fromColumnMajor(matrixArray);
}
/* Determine the view direction: */
Geometry::ComponentArray<GLfloat,3> viewDir(viewDirection.getXyzw());
if(autoViewDirection)
{
/* Get the projection matrix from OpenGL: */
GLfloat matrixArray[16];
glGetFloatv(GL_PROJECTION_MATRIX,matrixArray);
Geometry::Matrix<GLfloat,4,4> projection=Geometry::Matrix<GLfloat,4,4>::fromColumnMajor(matrixArray);
/* Calculate the view direction from the OpenGL projection and modelview matrices: */
Geometry::ComponentArray<GLfloat,4> viewPos(0.0f,0.0f,1.0f,0.0f);
viewPos=viewPos/projection;
viewPos=viewPos/modelView;
/* Check if it's an orthogonal or perspective projection: */
if(Math::abs(viewPos[3])<1.0e-8f)
{
/* Just copy the view direction: */
viewDir=viewPos;
}
else
{
/* Calculate the direction from the view point to the scene center: */
for(int i=0;i<3;++i)
viewDir[i]=viewPos[i]/viewPos[3]-sceneCenter[i];
}
GLfloat viewDirLen=GLfloat(Geometry::mag(viewDir));
for(int i=0;i<3;++i)
viewDir[i]/=viewDirLen;
}
/* Determine the light direction: */
Geometry::ComponentArray<GLfloat,3> lightDir(lightDirection.getXyzw());
if(autoLightDirection)
{
/* Query the light direction from OpenGL and transform it to model coordinates: */
Geometry::ComponentArray<GLfloat,4> lightPos;
glGetLightPosition(autoLightIndex,lightPos.getComponents());
lightPos=lightPos/modelView;
/* Check if it's a directional or point light: */
if(Math::abs(lightPos[3])<1.0e-8f)
{
/* Just copy the light direction: */
lightDir=lightPos;
}
else
{
/* Calculate the direction from the light source to the scene center: */
for(int i=0;i<3;++i)
lightDir[i]=lightPos[i]/lightPos[3]-sceneCenter[i];
}
GLfloat lightDirLen=GLfloat(Geometry::mag(lightDir));
for(int i=0;i<3;++i)
lightDir[i]/=lightDirLen;
}
/* Set up the OpenGL texture matrix: */
glMatrixMode(GL_TEXTURE);
glPushMatrix();
GLfloat matrix[4][4];
for(int j=0;j<3;++j)
{
matrix[j][0]=lightDir[j];
matrix[j][1]=viewDir[j];
matrix[j][2]=0.0f;
matrix[j][3]=0.0f;
}
matrix[3][0]=1.0f;
matrix[3][1]=1.0f;
matrix[3][2]=0.0f;
matrix[3][3]=2.0f;
glLoadMatrixf((const GLfloat*)matrix);
/* Set the OpenGL rendering mode: */
glPushAttrib(GL_TEXTURE_BIT);
glBindTexture(GL_TEXTURE_2D,dataItem->materialTextureId);
glEnable(GL_TEXTURE_2D);
if(dataItem->materialType==INTENSITY)
glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE);
else
glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_REPLACE);
/* Clean up: */
glMatrixMode(previousMatrixMode);
}
int main(int argc, char *argv[])
{
QCoreApplication app(argc, argv);
int res = 0;
QString appIni;
QMap<QString, QString> args = convertArgs(QCoreApplication::arguments());
if (!args.value("-f").isEmpty()) {
appIni = args.value("-f");
devIni = QFileInfo(appIni).dir().path() + QDir::separator() + "development.ini";
} else {
QString dir = QLatin1String("..") + QDir::separator() + QLatin1String("..") + QDir::separator() + "config" + QDir::separator();
appIni = dir + "application.ini";
devIni = dir + "development.ini";
}
if (!QFile::exists(appIni)) {
usage();
return 1;
}
QSettings appSetting(appIni, QSettings::IniFormat);
QSettings devSetting(devIni, QSettings::IniFormat);
// Default codec
QTextCodec *codec = QTextCodec::codecForName("UTF-8");
QString codecName = appSetting.value("InternalEncoding").toString();
if (!codecName.isEmpty()) {
QTextCodec *c = QTextCodec::codecForName(codecName.toLatin1().constData());
if (c) {
codec = c;
}
}
QTextCodec::setCodecForLocale(codec);
defaultTrimMode = devSetting.value("Erb.DefaultTrimMode", "1").toInt();
printf("Erb.DefaultTrimMode: %d\n", defaultTrimMode);
QDir viewDir(".");
if (!args.value("-v").isEmpty()) {
viewDir.setPath(args.value("-v"));
}
if (!viewDir.exists()) {
usage();
return 1;
}
QDir outputDir(DEFAULT_OUTPUT_DIR);
if (!args.value("-d").isEmpty()) {
outputDir.setPath(args.value("-d"));
}
if (outputDir.exists()) {
if (outputDir.path() != ".") {
printf(" exists %s\n", qPrintable(outputDir.path()));
}
} else {
if (outputDir.mkpath(".")) {
printf(" created %s\n", qPrintable(outputDir.path()));
} else {
usage();
return 1;
}
}
bool createProFile = (args.contains("-p") || !args.contains("-P"));
ViewConverter conv(viewDir, outputDir, createProFile);
QString templateSystem = devSetting.value("TemplateSystem").toString();
if (templateSystem.isEmpty()) {
templateSystem = appSetting.value("TemplateSystem", "Erb").toString();
}
res = conv.convertView(templateSystem);
return res;
}
void RV02::operator()(int argc,char *argv[]) {
/*********************************************/
/**** has always to be started (AMei) ****/
/**** if program is without gtk-Widgets ****/
/*********************************************/
gtkServer server;
server.start();
/******************************************/
/**** instantiation of used components ****/
/******************************************/
/*---------------------*/
/* loaders and viewers */
/*---------------------*/
loadBMP loader; // object for loading .bmp-images
viewer view("Original"); // object for visualizing images
/*---------------------*/
/* images & channels */
/*---------------------*/
image img; // normalized (color) image
channel8 src; // source picture // 8-bit-image (source)
channel8 med; // destination picture // 8-bit-image (source)
channel8 grad; // destination picture // 8-bit-image (source)
channel8 dir; // destination picture // 8-bit-image (source)
/*-----------------------------*/
/* Image processing components */
/*-----------------------------*/
// object to split image into hue, saturation and intensity
// hue = Farbton
// saturation = Farbsättigung
// intensity = Intensität (Grauwert)
splitImageToHSI splitter;
/******************************************/
/* the program */
/******************************************/
// load the source image
loader.load("shaft.bmp",img);
// extract the intensity channel only
splitter.getIntensity(img,src);
splitter.getIntensity(img,med);
splitter.getIntensity(img,grad);
splitter.getIntensity(img,dir);
// determine image size
const int rowSize = src.rows();
const int columnSize = src.columns();
// set destination size to source size
med.resize(rowSize,columnSize,0,false,true);
grad.resize(rowSize,columnSize,0,false,true);
dir.resize(rowSize,columnSize,0,false,true);
// MEDIAN
Median(src,med,9,9);
view.show(src);
viewer viewMed("Median");
viewMed.show(med);
// SOBEL
Sobel(src, grad, dir);
view.show(src);
viewer viewGrad("Gradient");
viewer viewDir("Direction");
viewGrad.show(grad);
viewDir.show(dir);
// view pictures
getchar();
}
AcDbIntArray & geomIds) const
#else
Acad::ErrorStatus PDEcone::getOsnapPoints(
AcDb::OsnapMode osnapMode,
int gsSelectionMark,
const AcGePoint3d& pickPoint,
const AcGePoint3d& lastPoint,
const AcGeMatrix3d& viewXform,
AcGePoint3dArray& snapPoints,
AcDbIntArray& geomIds) const
#endif
{
assertReadEnabled();
if(!hasSnap())
return Acad::eOk;
int gsSelectionMark_int = (int)gsSelectionMark;
if(gsSelectionMark_int == 0)
return Acad::eOk;
AcGePoint3dArray pArray;
AcGeIntArray stdIdx;
int actPrecision;
getVertices(m_dDividPrecision, pArray, stdIdx, actPrecision);
int actPrecision__1 = actPrecision + 1;
int stdIdxLen = stdIdx.length();
int stdIdxLen_1 = stdIdxLen - 1;
int stdIdxLen____2 = stdIdxLen / 2;
AcGeVector3d viewDir(viewXform(Z, 0), viewXform(Z, 1),
viewXform(Z, 2));
AcGeVector3d vect = getFaceVect();
int i;
switch(osnapMode)
{
case AcDb::kOsModeEnd:
snapPoints.append(m_ptStart);
snapPoints.append(m_ptEnd);
for(i = 0; i < stdIdxLen_1; ++i)
{
snapPoints.append(pArray[stdIdx[i]]);
snapPoints.append(pArray[stdIdx[i] + actPrecision__1]);
}
break;
case AcDb::kOsModeMid:
snapPoints.append(m_ptStart + (m_ptEnd - m_ptStart) / 2.0);
for(i = 0; i < stdIdxLen_1; ++i)
snapPoints.append(pArray[stdIdx[i]] +
(pArray[stdIdx[i] + actPrecision__1] - pArray[stdIdx[i]]) / 2.0);
break;
case AcDb::kOsModeCen:
if(gsSelectionMark_int == 1)
snapPoints.append(m_ptStart);
else if(gsSelectionMark_int == 2)
snapPoints.append(m_ptEnd);
else
snapPoints.append(m_ptStart + (m_ptEnd - m_ptStart) / 2.0);
break;
case AcDb::kOsModeQuad:
for(i = 0; i < stdIdxLen____2; i++)
{
snapPoints.append(pArray[stdIdx[i * 2]]);
snapPoints.append(pArray[stdIdx[i * 2] + actPrecision__1]);
}
break;
case AcDb::kOsModeNode:
break;
case AcDb::kOsModeIns:
snapPoints.append(m_ptStart);
break;
case AcDb::kOsModePerp:
{
AcGeLine3d line;
AcGeVector3d vec;
AcGePoint3d pt;
if(gsSelectionMark_int == 1)
{
AcGeCircArc3d cir(m_ptStart, vect, m_dDiameter1 / 2.0);
pt = cir.closestPointTo(lastPoint);
snapPoints.append(pt);
}
else if(gsSelectionMark_int == 2)
{
AcGeCircArc3d cir(m_ptEnd, vect, m_dDiameter2 / 2.0);
pt = cir.closestPointTo(lastPoint);
snapPoints.append(pt);
}
//重新定义对象垂直正交点的捕捉方式，同时满足实体模型和线框模型的捕捉
//modified by szw 2009.11.18 : begin
else if(gsSelectionMark_int == 3)
{
for(int i = 0; i < stdIdxLen - 1; ++i)
{
vec = pArray[stdIdx[i]] - pArray[stdIdx[i] + actPrecision__1];
line.set(pArray[stdIdx[i]], vec);
pt = line.closestPointTo(lastPoint);
snapPoints.append(pt);
}
}
//modified by szw 2009.11.18 : end
}
break;
case AcDb::kOsModeTan:
break;
case AcDb::kOsModeNear:
{
AcGePoint3d pt;
AcGeCircArc3d cir;
//下底面
if(gsSelectionMark_int == 1)
{
cir.set(m_ptStart, vect, m_dDiameter1 / 2.0);
pt = cir.projClosestPointTo(pickPoint, viewDir);
snapPoints.append(pt);
}
//上底面
else if(gsSelectionMark_int == 2)
{
cir.set(m_ptEnd, vect, m_dDiameter2 / 2.0);
pt = cir.projClosestPointTo(pickPoint, viewDir);
snapPoints.append(pt);
}
//棱边
//重新定义对象垂直正交点的捕捉方式，同时满足实体模型和线框模型的捕捉
//modified by szw 2009.11.18 : begin
else if(gsSelectionMark_int == 3)
{
AcGeLineSeg3d lnsg;
AcGePoint3d p1,p2;
for(int i = 0; i < stdIdxLen - 1; ++i)
{
p1 = pArray[stdIdx[i]];
p2 = pArray[stdIdx[i] + actPrecision__1];
lnsg.set(p1, p2);
// lnsg.set(pArray[stdIdx[i]], pArray[stdIdx[i] + actPrecision__1]);
pt = lnsg.projClosestPointTo(pickPoint, viewDir);
snapPoints.append(pt);
}
}
//modified by szw 2009.11.18 : end
}
break;
default:
break;
}
return Acad::eOk;
}
static void f6_key_prog (int x){ viewDir("."); }
int viewresults(void)
{
int k,kmenu;
void * pscr = NULL;
shortstr newname;
int dirStat=checkDir("results");
if(dirStat==0){messanykey(10,15,"directory RESULTS is empty"); return 1;}
kmenu = 1;
label_1:
menu1(10,10,"","\010"
" View "
" Delete "
" Rename ","s_res",&pscr,&kmenu);
switch (kmenu)
{
case 0:
return 0;
case 1:
viewDir("results");
break;
case 2:
if(dirStat==2)
{ char mess[]="Can not clean dir 'results' because it contains the LOCK file";
if(blind) { printf("%s\n",mess); sortie(102);}
else { messanykey(3,13,mess); break;}
}
if ( mess_y_n( 6,13," Delete files ") ) system("rm -r results; mkdir results");
put_text(&pscr);
return 1;
case 3:
strcpy(newname," ");
while(1)
{ void * pscr3;
get_text(1,maxRow(),maxCol(),maxRow(),&pscr3);
goto_xy(1,maxRow());
print("Enter new name: ");
k = str_redact(newname,1,30);
if (k == KB_ESC)
{ goto_xy(1,24);
clr_eol();
goto label_1;
}
if (k == KB_ENTER)
{
trim(newname);
if(rename("results",newname)==0)
{
mkdir("results",-1);
put_text(&pscr);
put_text(&pscr3);
return 1;
}
else messanykey(10,15," Can't rename the directory");
}
put_text(&pscr3);
}
}
goto label_1;
}
static void localF6(int x){ viewDir("./");}
