void ElXim::fill_with_el_image
(
Pt2di, Pt2di, Pt2di,
Im2D_U_INT1, Im2D_U_INT1, Im2D_U_INT1
)
{
ELISE_ASSERT(false,"ElXim::fill_with_el_image in ELISE_NO_VIDEO mode");
}
void SystLinSurResolu::AssertIndexEqValide(INT IndEq) const
{
ELISE_ASSERT
(
(IndEq>=0) && (IndEq<mNbEqCur),
"Bad Indexe in SystLinSurResolu"
);
}
void ElXim::fill_with_el_image
(
Pt2di, Pt2di, Pt2di,
std::vector<Im2D_INT4> &, Elise_Palette
)
{
ELISE_ASSERT(false,"ElXim::fill_with_el_image in ELISE_NO_VIDEO mode");
}
void SystLinSurResolu::AssertIndexGoodNbVar(INT aNbVar) const
{
ELISE_ASSERT
(
(aNbVar = mNbVarCur),
"Bad Indexe in SystLinSurResolu"
);
}
void SystLinSurResolu::AssertIndexVarValide(INT IndVar) const
{
ELISE_ASSERT
(
(IndVar>=0) && (IndVar<mNbVarCur),
"Bad Indexe in SystLinSurResolu"
);
}
ElImScroller & BiScroller::TheFirstScrAct()
{
if (Im1Act())
return Scr1();
ELISE_ASSERT(Im2Act(),"No Im Act in TheFirstScrAct");
return Scr2();
}
void UseRequirement(const std::string & aDir,const cTplValGesInit<cBatchRequirement> & aTplB)
{
if (! aTplB.IsInit())
return;
const cBatchRequirement & aBR = aTplB.Val();
for
(
std::list<cExeRequired>::const_iterator itE=aBR.ExeRequired().begin();
itE!=aBR.ExeRequired().end();
itE++
)
{
//std::string aCom = string("\"")+(g_externalToolHandler.get( "make" ).callName())+"\" " + itE->Exe() + " -f \"" + itE->Make() + "\"";
//System(aCom);
launchMake( itE->Make(), itE->Exe() );
}
for
(
std::list<cFileRequired>::const_iterator itF=aBR.FileRequired().begin();
itF!=aBR.FileRequired().end();
itF++
)
{
int aNbMin = itF->NbMin().Val();
int aNbMax = itF->NbMax().ValWithDef(aNbMin);
for
(
std::list<std::string>::const_iterator itP=itF->Pattern().begin();
itP!=itF->Pattern().end();
itP++
)
{
std::string aDir2,aPat2;
SplitDirAndFile(aDir2,aPat2,*itP);
aDir2 = aDir + aDir2;
std::list<std::string> aL=RegexListFileMatch(aDir2,aPat2,1,false);
int aNb = aL.size();
if ((aNb<aNbMin) || (aNb>aNbMax))
{
std::cout << "For Pattern {" << aPat2 << "} Number "
<< aNb << " Intervalle " << aNbMin << " / " << aNbMax << "\n";
ELISE_ASSERT(false,"File number required");
}
}
}
}
void cModeleAnalytiqueComp::TifSauvHomologues(const ElPackHomologue & aPack)
{
int aPas = mModele.PasCalcul();
if (! mModele.AutomNamesExportHomTif().IsInit())
return;
ELISE_ASSERT
(
mAppli.ExportForMultiplePointsHomologues().Val(),
"TifSauvHom, No::ExportForMultiplePointsHomologues"
);
if (mAppli.EchantillonagePtsInterets().IsInit())
{
ELISE_ASSERT
(
mAppli.EchantillonagePtsInterets().IsInit(),
"TifSauvHom, No::EchantillonagePtsInterets"
);
ELISE_ASSERT
(
mAppli.EchantillonagePtsInterets().Val().FreqEchantPtsI()==aPas,
"TifSauvHom, PasCalcul!=FreqEchantPtsI"
);
}
Pt2di aSzR = (mAppli.PDV1()->SzIm() + Pt2di(aPas-1,aPas-1)) / aPas;
cElImPackHom aImPack(aPack,aPas,aSzR);
std::string aNameTif = StdNameFromCple
(
mAutomExport,
mModele.AutomSelExportOri().Val(),
mModele.AutomNamesExportHomTif().Val(),
"@",
mAppli.PDV1()->Name(),
mAppli.PDV2()->Name()
);
aImPack.SauvFile(mAppli.FullDirResult()+aNameTif);
}
cEqRelativeGPS::cEqRelativeGPS
(
cRotationFormelle & aR1,
cRotationFormelle & aR2,
bool CodeGen
) :
mSet (aR1.Set()),
mR1 (&aR1),
mR2 (&aR2),
mDif21 ("Dif21")
{
ELISE_ASSERT(mSet==(mR2->Set()),"Different unknown in cEqRelativeGPS");
mR1->IncInterv().SetName("Ori1");
mR2->IncInterv().SetName("Ori2");
mLInterv.AddInterv(mR1->IncInterv());
mLInterv.AddInterv(mR2->IncInterv());
if (CodeGen)
{
Pt3d<Fonc_Num> aResidu = mR2->COpt() - mR1->COpt() - mDif21.PtF();
std::vector<Fonc_Num> aV;
aV.push_back(aResidu.x);
aV.push_back(aResidu.y);
aV.push_back(aResidu.z);
cElCompileFN::DoEverything
(
DIRECTORY_GENCODE_FORMEL, // Directory ou est localise le code genere
mNameType, // donne les noms de .cpp et .h de classe
aV, // expressions formelles
mLInterv // intervalle de reference
);
return;
}
mFoncEqResidu = cElCompiledFonc::AllocFromName(mNameType);
ELISE_ASSERT(mFoncEqResidu!=0,"Cannot allocate cEqObsBaseGPS");
mFoncEqResidu->SetMappingCur(mLInterv,mSet);
// GL
mDif21.InitAdr(*mFoncEqResidu);
mSet->AddFonct(mFoncEqResidu);
}
void cGenSysSurResol::GSSR_SolveEqFitDroite(REAL & aAx,REAL &aB,bool * aOk)
{
Im1D_REAL8 aSol = GSSR_Solve(aOk);
if (aOk && (! *aOk))
return;
ELISE_ASSERT(aSol.tx()==2,"cGenSysSurResol::GSSR_SolveEqFitDroite");
aAx = aSol.data()[0];
aB = aSol.data()[1];
}
void cGenSysSurResol::V_GSSR_EqMatIndexee
(
const std::vector<INT> & aVInd,
REAL aPds,REAL ** aMat,
REAL * aVect,REAL aCste
)
{
ELISE_ASSERT(false,"No cGenSysSurResol::GSSR_EqMatIndexee");
}
void coder_force(const char * aName)
{
bool aOk = code_file(aName,true);
if (! aOk)
{
std::cout << "For name " << aName << "\n";
ELISE_ASSERT(false,"cannot code");
}
}
Box2dr Elise_Rect::ToBoxR(void) const
{
ELISE_ASSERT(_dim==2,"Bad Dim in Elise_Rect::ToBoxR");
return Box2dr
(
Pt2dr(_p0[0],_p0[1]),
Pt2dr(_p1[0],_p1[1])
);
}
const cContrainteEQF & cMultiContEQF::KthC(int aKth) const
{
ELISE_ASSERT
(
(aKth>=0) && (aKth<int(mContraintes.size())),
"cMultiContEQF::KthC"
);
return mContraintes[aKth];
}
const cPixelSortie_Convol & cLineSortie_Convol::Pix(int aPix) const
{
ELISE_ASSERT
(
(aPix>=mPixOut0) && (aPix<mPixOut1),
"Bad Access to cLineSortie_Convol::Pix"
);
return mVPSC[aPix-mPixOut0];
}
void RImGrid::SetValueGrid(Pt2di aP,REAL aV)
{
ELISE_ASSERT
(
(aP.x>=0)&&(aP.x<mSzGrid.x)&&(aP.y>=0)&&(aP.y<mSzGrid.y),
"Out Of RImGrid::SetValueGrid"
);
mGrid.data()[aP.y][aP.x] = aV;
}
Pt3dr cGenSysSurResol::Pt3dSolInter(bool * aOk)
{
Im1D_REAL8 aSol = GSSR_Solve(aOk);
if (aOk && (! *aOk))
return Pt3dr(1e33,-1e44,0);
ELISE_ASSERT(aSol.tx()==3,"cGenSysSurResol::SolInter");
return Pt3dr(aSol.data()[0],aSol.data()[1],aSol.data()[2]);
}
void Verif(Pt2df aPf)
{
Pt2dr aPd = ToPt2dr(aPf);
if (std_isnan(aPd.x) || std_isnan(aPd.y))
{
std::cout << "PB PTS " << aPf << " => " << aPd << "\n";
ELISE_ASSERT(false,"PB PTS in Verif");
}
}
void cLEqHomOneDist::AddEqF(cEqHomogFormelle * pEq)
{
ELISE_ASSERT(mDRF ==pEq->DRF(),"Multiple Dist in cLEqHomOneDist");
mEqFs.push_back(pEq);
AddHomogF(&pEq->HF1());
AddHomogF(&pEq->HF2());
mLiaisons.push_back(new ElPackHomologue);
}
void cElHJaFacette::MakeAdjacences()
{
for (INT aK=0 ; aK<INT(mVArcs.size()) ; aK++)
{
tArcGrPl * aArc1 = &(mVArcs[aK]->arc_rec());
tArcGrPl * aArc2 = mVArcs[aK]->attr().ArcHom();
tArcGrPl * aArc3 = (aArc2==0) ? 0 : &(aArc2->arc_rec());
cElHJaFacette * aF1 = aArc1->attr().Fac();
cElHJaFacette * aF3 = (aArc3==0) ? 0 :aArc3->attr().Fac();
cElHJaFacette * aF2 = (aArc2==0) ? 0 :aArc2->attr().Fac();
ELISE_ASSERT((aF1==0)==(aF3==0),"cElHJaFacette::MakeAdjacences");
ELISE_ASSERT((aF1==0)==(aF2==0),"cElHJaFacette::MakeAdjacences");
mVFAdjcPl.push_back(aF1);
mVFAdjcComp.push_back(aF3);
mVFAdjcIncomp.push_back(aF2);
}
}
void xml_init(cElRegex_Ptr & aPtrReg ,cElXMLTree * aTree)
{
aPtrReg = new cElRegex(aTree->Contenu(),30);
if (aPtrReg==0)
{
std::cout << "REGEX=[" << aTree->Contenu() << "]\n";
ELISE_ASSERT(false,"Cannot Compile Regular Expression");
}
}
void xml_init(Pt3di & aP,cElXMLTree * aTree)
{
int aNb = sscanf(aTree->Contenu().c_str(),"%d %d %d %s",&aP.x,&aP.y,&aP.z,aBuf);
if (aNb!=3)
{
std::cout << "CONTENU = " << aTree->Contenu().c_str() << "\n";
ELISE_ASSERT(false,"Bad Nb Value in xml_init (double)");
}
}
void decoder_force(const char * aName,std::string & aNew)
{
bool aOk = code_file(aName,false,&aNew);
if (! aOk)
{
std::cout << "For name " << aName << "\n";
ELISE_ASSERT(false,"cannot decode");
}
}
void cGradConjSolveur<TVect,TMul,TCond>::VerifResidu()
{
double aResisu = MpdGC_Residu() ;
if (aResisu > aEpsResidu)
{
std::cout << "RESIDU = " << aResisu << "\n";
ELISE_ASSERT(false,"cGradConjSolveur::VerifResidu");
}
}
cEqOffsetGPS::cEqOffsetGPS(cRotationFormelle & aRF,cBaseGPS & aBase,bool doGenCode) :
mSet (aRF.Set()),
mRot (&aRF),
mBase (&aBase),
mGPS ("GPS"),
mNameType ("cEqObsBaseGPS" + std::string(aRF.IsGL() ? "_GL" : "")),
mResidu (mRot->C2M(mBase->BaseInc())- mGPS.PtF()),
mFoncEqResidu (0)
{
/*
ELISE_ASSERT
(
(! aRF.IsGL()),
"cEqOffsetGPS to complete in Gimbal Lock Mode"
);
*/
AllowUnsortedVarIn_SetMappingCur = true;
ELISE_ASSERT
(
mRot->Set()==mBase->Set(),
"cEqOffsetGPS Rotation & Base do no belong to same set of unknown"
);
mRot->IncInterv().SetName("Orient");
mBase->IncInterv().SetName("Base");
mLInterv.AddInterv(mRot->IncInterv());
mLInterv.AddInterv(mBase->IncInterv());
if (doGenCode)
{
GenCode();
return;
}
mFoncEqResidu = cElCompiledFonc::AllocFromName(mNameType);
ELISE_ASSERT(mFoncEqResidu!=0,"Cannot allocate cEqObsBaseGPS");
mFoncEqResidu->SetMappingCur(mLInterv,mSet);
// GL
mGPS.InitAdr(*mFoncEqResidu);
mSet->AddFonct(mFoncEqResidu);
}
template <class Type> Box2d<Type>::Box2d(const Pt2d<Type> *aVPts,INT nb)
{
ELISE_ASSERT(nb!=0,"Box2d<Type>::Box2d(const Pt2d<Type> *x,INT nb");
_p0 = _p1 = aVPts[0];
for (INT aK=1; aK<nb ; aK++)
{
_p0.SetInf(aVPts[aK]);
_p1.SetSup(aVPts[aK]);
}
}
cObsLiaisonMultiple * cPackObsLiaison::ObsMulOfName(const std::string & aName)
{
cObsLiaisonMultiple * aRes = mDicoMul[aName];
if (aRes==0)
{
std::cout << "For Name =" << aName << "\n";
ELISE_ASSERT(false,"cPackObsLiaison::ObsMulOfName");
}
return aRes;
}
cPackObsLiaison * cAppliApero::PackOfInd(const std::string& anId)
{
cPackObsLiaison * aPOL = mDicoLiaisons[anId];
if (aPOL==0)
{
std::cout << "---------------- ID = " << anId <<"\n";
ELISE_ASSERT(false,"Cannot find Id for pack liaison");
}
return aPOL;
}
cLayerImage * cAppliApero::LayersOfName(const std::string & aName)
{
cLayerImage * aLI = mMapLayers[aName];
if (aLI==0)
{
std::cout << " Id=" << aName << "\n";
ELISE_ASSERT(false,"Unkown Layer in cAppliApero::SplitHomFromImageLayer");
}
return aLI;
}
void cAppliApero::InitOneSurfParam(const cSurfParamInc & aParamSurf)
{
if (aParamSurf.InitSurf().ZonePlane().IsInit())
{
const std::string & aName = aParamSurf.InitSurf().ZonePlane().Val();
cSurfParam * aSurf = mDicoSurfParam[aName];
if (aSurf==0)
{
std::cout << "For name surf = " << aName << "\n";
ELISE_ASSERT(false,"surf pas initialise");
}
aSurf->MakeInconnu(aParamSurf);
}
else
{
ELISE_ASSERT(false,"SurfParamInc :: ne gere que les plans ");
}
}
