将传递的AcGsView设置为*Active*AutoCAD AcDbDatabase视图

admin1

// get the view port information - see parameter list
        static bool GetActiveViewPortInfo (AcDbDatabase *pDb, ads_real &height, ads_real &width,
                                                                AcGePoint3d &target, AcGeVector3d &viewDir,
                                                                ads_real &viewTwist,
                                                                AcDbObjectId &currentVsId,
                                                                bool getViewCenter)
        {
          // if not ok
          if (pDb == NULL)
                return false;

          // get the current document associated with the PDb database and set it current
  
          AcApDocument *pDoc = acDocManager->document(pDb);
          acDocManager->setCurDocument(pDoc);
          acDocManager->lockDocument(pDoc);

          // make sure the active view port is uptodate
          acedVports2VportTableRecords();

          // open the view port records
          AcDbViewportTablePointer pVTable(pDb->viewportTableId(), AcDb::kForRead);
          // if we opened them ok
          if (pVTable.openStatus() == Acad::eOk)
          {
                AcDbViewportTableRecord *pViewPortRec = NULL;
                Acad::ErrorStatus es = pVTable->getAt (_T("*Active"), pViewPortRec, AcDb::kForRead);
                if (es == Acad::eOk)
                {
                  // get the height of the view
                  height = pViewPortRec->height ();
                  // get the width
                  width = pViewPortRec->width ();
                  // if the user wants the center of the viewport used
                  if (getViewCenter == true)
                  {
                        struct resbuf rb;
                        memset (&rb, 0, sizeof (struct resbuf));
                        // get the system var VIEWCTR
                        acedGetVar (_T("VIEWCTR"), &rb);
                        // set that as the target
                        target = AcGePoint3d (rb.resval.rpoint[X], rb.resval.rpoint[Y], rb.resval.rpoint[Z]);
                  }
                  // we want the viewport's camera target setting
                  else
                  {
                        // get the target of the view
                        target = pViewPortRec->target ();
                  }               

                  // get the view direction
                  viewDir = pViewPortRec->viewDirection ();
                  // get the view twist of the viewport
                  viewTwist = pViewPortRec->viewTwist ();
                  // return the current Visual Style
                  currentVsId = pViewPortRec->visualStyle();
                }
                // close after use
                pViewPortRec->close();                       
          }       

          acDocManager->unlockDocument(pDoc);
          // now restore the original document
          acDocManager->setCurDocument(acDocManager->mdiActiveDocument());

          return (true);
        }

                //////////////////////////////////////////////////////////////////////////
        // set the passed AcGsView to the *Active* AutoCAD AcDbDatabase view
        static AcDbObjectId SetViewTo(AcGsView *pView, AcDbDatabase *pDb, AcGeMatrix3d& viewMat)
        {
          // we are going to set the view to the current view of the drawing
          // The overall approach is to calculate the extents of the database in the coordinate system of the view
          // Calculate the extents in WCS
          AcGePoint3d extMax = pDb->extmax();
          AcGePoint3d extMin = pDb->extmin();

          // initialize it with sensible numbers - even if there is no entity
          if (extMin.distanceTo(extMax) > 1e20)
          {
                  extMin.set(0, 0, 0);
                  extMax.set(100, 100, 100);
          }

          // get the view port information - see parameter list
          ads_real height = 0.0, width = 0.0, viewTwist = 0.0;
          AcGePoint3d targetView;
          AcGeVector3d viewDir;
          AcDbObjectId currentVsId;
          GetActiveViewPortInfo (pDb, height, width, targetView, viewDir, viewTwist, currentVsId, true);

          // we are only interested in the directions of the view, not the sizes, so we normalise.
          viewDir = viewDir.normal();

          //**********************************************
          // Our view coordinate space consists of z direction
          // get a perp vector off the z direction
          // Make sure its normalised
          AcGeVector3d viewXDir = viewDir.perpVector ().normal();
          // correct the x angle by applying the twist
          viewXDir = viewXDir.rotateBy (viewTwist, -viewDir);
          // now we can work out y, this is of course perp to the x and z directions. No need to normalise this,
          // as we know that x and z are of unit length, and perpendicular, so their cross product must be on unit length
          AcGeVector3d viewYDir = viewDir.crossProduct (viewXDir);

          // find a nice point around which to transform the view. We'll use the same point as the center of the view.
          AcGePoint3d boxCenter = extMin + 0.5 * ( extMax - extMin );

          //**********************************************
          // create a transform from WCS to View space
          // this represents the transformation from WCS to the view space. (Actually not quite since
          // we are keeping the fixed point as the center of the box for convenience )
          viewMat = AcGeMatrix3d::alignCoordSys (boxCenter, AcGeVector3d::kXAxis, AcGeVector3d::kYAxis, AcGeVector3d::kZAxis,  
                boxCenter, viewXDir, viewYDir, viewDir).inverse();

          AcDbExtents wcsExtents(extMin, extMax);
          // now we have the view Extents
          AcDbExtents viewExtents = wcsExtents;
          // transforms the extents in WCS->view space
          viewExtents.transformBy (viewMat);

          //**********************************************
          // get the extents of the AutoCAD view
          double xMax = fabs(viewExtents.maxPoint ().x - viewExtents.minPoint ().x);
          double yMax = fabs(viewExtents.maxPoint ().y - viewExtents.minPoint ().y);

          //**********************************************
          // setup the view
          AcGePoint3d eye = boxCenter + viewDir;

          // upvector                               
          pView->setView(eye, boxCenter, viewYDir, xMax, yMax);
          // update the gsView
          refreshView(pView);

          return currentVsId;
        }

        static void refreshView(AcGsView *pView)
        {
          if (pView != NULL)
          {
                pView->invalidate();
                pView->update();
          }
        }

        static Acad::ErrorStatus CreateAnonBlock(AcArray<AcDbObjectId> &selectedIds, AcDbObjectId &idAnonBlock)
        {
                Acad::ErrorStatus es;
                AcDbBlockTable *pBlockTable = NULL;

                AcDbDatabase *pDb = acdbHostApplicationServices()->workingDatabase();

                AcDbBlockTableRecord *pAnonBlock = NULL;
                if( idAnonBlock == AcDbObjectId::kNull )
                {
                        if ((es = pDb->getBlockTable(pBlockTable, AcDb::kForWrite))
                                != Acad::eOk)
                        {
                                acutPrintf(L"Could not open block table.\n");
                                return es;
                        }

                        AcDbBlockTableRecord* pAnonBlock = new AcDbBlockTableRecord;
                        if(!pAnonBlock)
                        {
                                acutPrintf(L"Could not create new block table record.\n");
                                return Acad::eNullObjectPointer;
                        }
                        if((es = pAnonBlock->setName(_T("*U"))) != Acad::eOk)
                        {
                                acutPrintf(L"Could not name anonymous block.\n");
                                return es;
                        }
                        if((es = pBlockTable->add(idAnonBlock, pAnonBlock)) != Acad::eOk)
                        {
                                acutPrintf(L"Could not add anonymous block to block table.\n");
                                return es;
                        }

                        if((es = pBlockTable->close()) != Acad::eOk)
                        {
                                acutPrintf(L"Could not close block table.\n");
                                return es;
                        }
                        if((es = pAnonBlock->close()) != Acad::eOk)
                        {
                                acutPrintf(L"Could not close block table record.\n");
                                return es;
                        }
                }

                AcDbObjectPointer<AcDbBlockTableRecord> pAnonBlockObjectPtr(idAnonBlock, AcDb::kForWrite);

                if((es = pAnonBlockObjectPtr.openStatus()) != Acad::eOk)
                {
                        acutPrintf(L"Could not open anonymous block.\n");
                        return es;
                }


                for(int cnt = 0; cnt < selectedIds.length(); cnt++)
                {
                        AcDbObjectId entId = selectedIds.at(cnt);

                        AcDbObjectPointer<AcDbEntity> pEntity(entId, AcDb::kForRead);
                        if(Acad::eOk == pEntity.openStatus())
                        {
                                AcDbEntity *pCloneEnt = (AcDbEntity *) pEntity->clone();
                               
                                if((es = pAnonBlockObjectPtr->appendAcDbEntity(pCloneEnt)) != Acad::eOk)
                                {
                                        acutPrintf(L"Could not append entity to anonymous block.\n");
                                        return es;
                                }

                                if((es = pCloneEnt->close()) != Acad::eOk)
                                {
                                        acutPrintf(L"Could not close entity.\n");
                                        return es;
                                }
                        }
                }

                return Acad::eOk;
        }

        static bool CreateAtilImage(AcGsView *pView,
                                                 int width, int height,
                                                 int colorDepth, int paletteSize,
                                                 ACHAR *pFileName)
        {
          bool done = false;

          AcGsDCRect screenRect(0,width,0, height);
       
          // get the screen rect from the gsview
                pView->getViewport(screenRect);

          try
          {
                // we want colorDepth to be either 24 or 32
                if (colorDepth < 24)
                  colorDepth = 24;
                if (colorDepth > 24)
                  colorDepth = 32;

                // create rbgmodel 32 bit true color
                Atil::RgbModel rgbModel(colorDepth);
                Atil::ImagePixel initialColor(rgbModel.pixelType());
                // create the Atil image on the stack
                Atil::Image imgSource(Atil::Size(width, height), &rgbModel, initialColor);

                // get a snapshot of the GsView
                pView->getSnapShot(&imgSource, screenRect.m_min);

                // if ok
                if (imgSource.isValid())
                {
                  Atil::RowProviderInterface *pPipe = imgSource.read(imgSource.size(), Atil::Offset(0,0),Atil::kBottomUpLeftRight);
                  if(pPipe != NULL)
                  {
                        TCHAR drive[_MAX_DRIVE];
                        TCHAR dir[_MAX_DIR];
                        TCHAR fname[_MAX_FNAME];
                        TCHAR ext[_MAX_EXT];       
                        // find out what extension we have
                        _tsplitpath_s(pFileName, drive, dir, fname, ext);

                        Atil::ImageFormatCodec *pCodec = NULL;
                        // create the codec depending on what the user chose

                        if (CString(ext) == _T(".jpg"))
                          pCodec = new JfifFormatCodec();
                        else if (CString(ext) == _T(".png"))
                          pCodec = new PngFormatCodec();
                        else if (CString(ext) == _T(".tif"))
                          pCodec = new TiffFormatCodec();
                        else if (CString(ext) == _T(".bmp"))
                          pCodec = new BmpFormatCodec();

                        // if we have a new codec
                        if (pCodec != NULL)
                        {
                          // and it is compatible
                          if (Atil::FileWriteDescriptor::isCompatibleFormatCodec(pCodec, &(pPipe->dataModel()), pPipe->size()))
                          {
                                // create a new file output object
                                Atil::FileWriteDescriptor fileWriter(pCodec);
                                Atil::FileSpecifier fs(Atil::StringBuffer((lstrlen(pFileName) + 1) * sizeof(TCHAR),
                                  (const Atil::Byte *)pFileName, Atil::StringBuffer::kUTF_16), Atil::FileSpecifier::kFilePath);

                                // if the file already exists
                                // we better delete it because setFileSpecifier will fail otherwise
                                _tremove(pFileName);

                                if (fileWriter.setFileSpecifier(fs))
                                {
                                  fileWriter.createImageFrame(pPipe->dataModel(), pPipe->size());

                                  // At any rate you want to fetch the property from the write file descriptor then alter it and set it in…
                                  Atil::FormatCodecPropertyInterface *pProp = fileWriter.getProperty(Atil::FormatCodecPropertyInterface::kCompression);
                                  if (pProp != NULL)
                                  {
                                        if (CString(ext) == _T(".jpg"))
                                        {
                                          Atil::FormatCodecIntProperty *pComp = dynamic_cast<Atil::FormatCodecIntProperty*>(pProp);
                                          if (pComp != NULL)
                                          {
                                                int min=0, max=0;
                                                pComp->getPropertyLimits(min, max);
                                                // set the quality to 90%
                                                pComp->setValue((int)((double)max * .9));

                                                // apply any changes we have made
                                                fileWriter.setProperty(pComp);
                                          }
                                        }                  
                                        else if (CString(ext) == _T(".png"))
                                        {
                                          PngCompression *pComp = dynamic_cast<PngCompression*>(pProp);
                                          if (pComp != NULL)
                                          {
                                                // Why not compress all we can?
                                                pComp->selectCompression(PngCompressionType::kHigh);

                                                // apply any changes we have made
                                                fileWriter.setProperty(pComp);
                                          }
                                        }
                                        else if (CString(ext) == _T(".tif"))
                                        {
                                          // All image types can be compressed using kNone, kLZW, and kDeflate.
                                          // If it is 8 bit (palette'd or gray scale) the kPackbits is available.
                                          // If it is 1 bit (bi-tonal) then the CCITT family of kCCITT_* compression of which the kCCITT_FAX4 is the best are available.
                                          // If it is 24 bit (3 channel RGB) then kJPEG is available which will use JPEG DCT compression in the TIFF file.
                                          TiffCompression *pComp = dynamic_cast<TiffCompression*>(pProp);
                                          if (pComp != NULL)
                                          {
                                                // G4 is only valid for 1 bit images.
                                                if (pComp->selectCompression(TiffCompressionType::kCCITT_FAX4) == false)
                                                {
                                                  // So if that fails, resort to LZW now that it is patent free
                                                  if (pComp->selectCompression(TiffCompressionType::kLZW) == false)
                                                  {
                                                        // If that fails (and is shouldn’t, be) then set none.
                                                        pComp->selectCompression(TiffCompressionType::kNone);
                                                  }
                                                }
                                                // apply any changes we have made
                                                fileWriter.setProperty(pComp);
                                          }
                                        }

                                        // clean up
                                        delete pProp;
                                        pProp = NULL;
                                  }
                                }

                                // be sure that the format has all the information it needs to write the file.
                                // In ATIL every property is required to have a valid default value.
                                // So if a certain property is REQUIRED by the codec to save the file, then it is safe
                                // and proper to simply loop over all the possible properties, enquire if it is required
                                // and simply set it with it’s default value
                                Atil::FormatCodecPropertySetIterator* pPropsIter = fileWriter.newPropertySetIterator();
                                // if ok
                                if (pPropsIter)
                                {
                                  for (pPropsIter->start(); !pPropsIter->endOfList(); pPropsIter->step())
                                  {
                                        Atil::FormatCodecPropertyInterface* pProp = pPropsIter->openProperty();
                                        if (pProp->isRequired())
                                        {
                                          fileWriter.setProperty(pProp);
                                        }
                                        pPropsIter->closeProperty();
                                  }
                                  delete pPropsIter;
                                }

                                // ok - ready to write it
                                fileWriter.writeImageFrame(pPipe);
                                done = true;
                          }
                        }
                        delete pCodec;
                  }
                }
          }
          catch ( Atil::ATILException e )
          {
                const Atil::StringBuffer *pStringMsg =e.getMessage();
          }

          return done;
        }

        static void AdskMyTestTSSARX()
        {
                AcArray<AcDbObjectId> selectedIds;

                while(true)
                {
                        ads_name ename;
                        ads_point pickPt;
                       
                        acedInitGet(NULL, NULL);
                        int rc = acedEntSel(_T("\nSelect Entity"), ename, pickPt);
                       
                        if(rc == RTCAN || rc == RTERROR)
                                break;

                        if(rc == RTNORM)
                        {
                                AcDbObjectId entId;
                                acdbGetObjectId(entId, ename);
                                selectedIds.append(entId);
                        }
                }

                if(selectedIds.length() == 0)
                        return;

                AcDbObjectId annonBlockId = AcDbObjectId::kNull;

                CreateAnonBlock(selectedIds, annonBlockId);

                AcGsManager *gsManager = acgsGetGsManager();

                struct resbuf screensize;
                acedGetVar(_T("SCREENSIZE"), &screensize);
                double screenSizeX = screensize.resval.rpoint[0];
                double screenSizeY = screensize.resval.rpoint[1];

                int width = screenSizeX;
                int height = screenSizeY;

                AcGsDevice *offDevice = gsManager->createAutoCADOffScreenDevice();

                offDevice->onSize(width, height);

                AcGsClassFactory *pGSFactory = gsManager->getGSClassFactory();   

                AcGsView *pView = pGSFactory->createView();

                offDevice->add(pView);

                offDevice->update();

                AcGsModel *pModel = gsManager->createAutoCADModel();

                AcDbBlockTableRecordPointer annonblk(annonBlockId, AcDb::kForRead);
                if (annonblk.openStatus() == Acad::eOk)
                {
                        pView->add(annonblk, pModel);

                        AcDbExtents extents;
                        extents.addBlockExt(annonblk);
                        _extMin = extents.minPoint();
                        _extMax = extents.maxPoint();

                        AcDbDatabase *pDb = acdbHostApplicationServices()->workingDatabase();
                        AcGeMatrix3d viewMat;
                        SetViewTo(pView, pDb, viewMat);
                }

                refreshView(pView);

                AcGsDCRect screenRect(0,width,0, height);
                pView->getViewport(screenRect);

                CWnd *gsViewWnd = acedGetAcadDwgView();
                if (gsViewWnd != NULL)
                {
                        CRect sizeRect;
                        gsViewWnd->GetClientRect(&sizeRect);

                        int colorDepth = 32;
                        int paletteSize = 0;

                        CreateAtilImage(pView, sizeRect.Width(), sizeRect.Height(), colorDepth, paletteSize, ACRX_T("C:\\Temp\\Test_Arx.bmp"));
                }

                pView->eraseAll();
                offDevice->erase(pView);
                pGSFactory->deleteView(pView);
                pGSFactory->deleteModel(pModel);
        }
};

AcGePoint3d CMyTest1App::_extMin;
AcGePoint3d CMyTest1App::_extMax;

jxmjg

  法拉利膜材作为一种高性能的建筑材料，在建筑、汽车及广告等多个领域有着广泛的应用。以下是对法拉利膜材型号、特点及优点的详细分析：
[img]http://www.mjgou.com/data/attachment/forum/202403/13/223041uiqmeujen4jjj6zv.jpg[/img]
[b]一、法拉利膜材型号[/b]
法拉利膜材有多种型号，包括但不限于以下几种：1302 S2 Flexlight Advanced：这是一种高性能IV型柔性复合膜材，以其卓越的透光性、耐久性和易维护性而受到青睐。942、1202 S2、1002 S2、902 S2、1212 S2、912 S2：这些型号同样属于法拉利膜材系列，各自具有不同的特性和适用范围，但具体特点需根据具体型号进一步分析。需要注意的是，法拉利膜材的型号可能随着产品更新换代而有所变化，具体型号及其特性请参考最新产品资料。
[img=860,1255]http://www.mjgou.com/data/attachment/forum/202403/13/223254bbblwlbvbvsbwlsl.jpg[/img]
[b]二、法拉利膜材特点[/b]
法拉利膜材的特点主要体现在以下几个方面：
1、高强度与耐用性：法拉利膜材采用高强度材料制成，具有良好的抗拉强度和撕裂强度，能够承受较大的外力作用而不易破损。耐用性强，能够在恶劣气候条件下保持稳定的性能，延长使用寿命。
2、透光性与美观性：部分型号如1302 S2 Flexlight Advanced具有高透光性，能够在保持室内光线充足的同时，提供清晰的视野。膜材表面平整光滑，色彩丰富多样，能够满足不同建筑和装饰需求，提升整体美观性。
3、轻质与灵活性：法拉利膜材重量较轻，便于运输和安装，能够降低施工成本和时间。膜材具有一定的柔韧性，能够适应各种复杂形状和结构的设计要求。
4、环保与可回收性：法拉利膜材符合环保要求，部分材料可回收利用，减少了对环境的影响。
[img]http://www.mjgou.com/data/attachment/forum/202403/13/223128owhn0099rrds5h5y.jpg[/img]
[b]三、法拉利膜材优点[/b]
法拉利膜材的优点主要体现在以下几个方面：
1、提升建筑性能：高强度与耐用性使得法拉利膜材能够提升建筑的稳定性和安全性，延长使用寿命。透光性与美观性使得建筑内部光线充足、视野开阔，同时提升整体美观度。
2、降低施工成本：轻质特性使得运输和安装成本降低，施工效率提高。膜材的柔韧性使得施工更加灵活多变，能够适应各种复杂地形和结构要求。
3、节能环保：部分材料可回收利用，符合环保要求，减少了对环境的影响。良好的透光性能够减少室内照明需求，降低能耗。
4、广泛应用领域：
法拉利膜材不仅适用于建筑领域（如体育设施、商业设施、文化设施、交通设施等），还广泛应用于汽车及广告领域（如高档车辆贴膜保护和装饰、广告招贴等），展现出其多功能的特性。

综上所述，法拉利膜材以其高强度、耐用性、透光性、美观性、轻质灵活性以及环保可回收性等优点，在建筑、汽车及广告等多个领域发挥着重要作用。具体型号的选择应根据实际需求和应用场景进行综合考虑。
[url=http://www.mjgou.com/forum-17-1.html][size=92164][color=Red]法拉利膜材中国代理商 - 膜结构网[/color][/size][/url]

泰康利膜代理商

泰康利膜材，作为美国泰康利（Taconic）公司旗下的重要产品系列，以其优异的性能和广泛的应用领域在建筑、工业等多个行业中占据重要地位。以下是对泰康利膜材的详细分析：
[b]一、公司背景与实力[/b]
公司概况：
成立时间：1961年，由美国企业家Lester在纽约Petersburgh创立。
发展历程：自创立以来，Taconic始终在研发及销售高性能合成材料的行业中占有主导地位。1975年在爱尔兰成立工厂，1996年在韩国成立工厂，2006年在巴西成立工厂。
市场地位：作为全球铁氟龙（Teflon/PTFE）产品的主导公司，Taconic的产品出口到约四十个国家。
子公司：泰康利复合材料(苏州)有限公司是Taconic亚太总部韩国Taconic于2008年投资创立的全资子公司，主要负责中国境内的产品销售和技术服务。

[b]二、产品特点[/b]
泰康利膜材，特别是其PTFE膜材系列，具有以下显著特点：
高强度：膜材能够承受较大的拉伸和撕裂力，确保结构的稳定性和安全性。
耐久性：材料经久耐用，能够在各种恶劣环境下长期使用而不易损坏。
防火性：具有良好的阻燃性能，提高建筑的安全性。
耐腐蚀性：能够抵抗多种化学物质的侵蚀，延长使用寿命。
自洁性：雨水自然冲刷即可保持膜材表面的清洁，减少维护成本。
抗紫外线：有效阻挡紫外线，保护内部材料和结构不受损害。
[b]三、产品系列与型号[/b]
泰康利膜材的PTFE膜材系列包括多个型号，如Solus 850、Solus 1110、Solus 1120、Solus 1420等。这些型号在厚度、透光率、拉伸强度等性能上略有差异，以满足不同应用场景的需求。
[b]四、应用领域[/b]
泰康利膜材广泛应用于多个领域，包括但不限于：
建筑领域：用于体育场馆、展览馆、机场航站楼等大型公共建筑的屋顶和墙面覆盖，提供美观、耐用且功能强大的建筑解决方案。
工业领域：在压力感应胶带、工程传输带、硅橡胶涂层产品等方面有广泛应用，满足工业生产的各种需求。
环保与能源领域：在风力发电领域，PTFE膜材作为叶片涂层或发电机罩材料，提高设备的运行效率和耐久性，推动清洁能源的发展。
[b]五、环保与可持续性[/b]
Taconic公司注重环保与可持续性发展，采取有效策略减少对环境的影响。例如，在生产和应用过程中回收利用和循环利用PTFE膜材料，降低资源消耗和碳排放。
[b]六、总结[/b]
泰康利膜材作为Taconic公司的核心产品之一，以其优异的性能和广泛的应用领域在市场上享有很高的声誉。随着科技的不断进步和市场的不断发展，泰康利膜材将继续保持其领先地位，为客户提供更加优质的产品和服务。同时，Taconic公司也将继续致力于环保与可持续性发展，推动行业的绿色转型。