291 lines
15 KiB
C++
291 lines
15 KiB
C++
// -*- C++ -*-
|
|
//
|
|
// This file is part of the Coriolis Software.
|
|
// Copyright (c) Sorbonne Université 2020-2021, All Rights Reserved
|
|
//
|
|
// +-----------------------------------------------------------------+
|
|
// | C O R I O L I S |
|
|
// | I s o b a r - Hurricane / Python Interface |
|
|
// | |
|
|
// | Author : Jean-Paul CHAPUT |
|
|
// | E-mail : Jean-Paul.Chaput@lip6.fr |
|
|
// | =============================================================== |
|
|
// | C++ Module : "./PyDbU.cpp" |
|
|
// +-----------------------------------------------------------------+
|
|
|
|
|
|
#include "hurricane/configuration/PyDbU.h"
|
|
|
|
|
|
namespace Isobar3 {
|
|
|
|
using namespace Hurricane;
|
|
|
|
extern "C" {
|
|
|
|
|
|
// Thin wrappers for overloadeds member functions.
|
|
|
|
void setPrecision1 ( long precision ) { DbU::setPrecision( precision ); }
|
|
void setGridsPerLambda1 ( double ratio ) { DbU::setGridsPerLambda( ratio ); }
|
|
|
|
DbU::Unit fromGridLong ( long u ) { return DbU::fromGrid( (double)u ); }
|
|
DbU::Unit fromGridDouble ( double u ) { return DbU::fromGrid( u ); }
|
|
DbU::Unit fromLambdaLong ( long u ) { return DbU::fromLambda( (double)u ); }
|
|
DbU::Unit fromLambdaDouble ( double u ) { return DbU::fromLambda( u ); }
|
|
|
|
double toGridLong ( long u ) { return DbU::toGrid( (double)u ); }
|
|
double toGridDouble ( double u ) { return DbU::toGrid( u ); }
|
|
double toLambdaLong ( long u ) { return DbU::toLambda( (double)u ); }
|
|
double toLambdaDouble ( double u ) { return DbU::toLambda( u ); }
|
|
double toPhysicalLong ( long u, long p ) { return DbU::toPhysical( (double)u, (DbU::UnitPower)p ); }
|
|
double toPhysicalDouble ( double u, long p ) { return DbU::toPhysical( u, (DbU::UnitPower)p ); }
|
|
|
|
DbU::Unit getOnCustomGrid2 ( DbU::Unit u, DbU::Unit step )
|
|
{ return DbU::getOnCustomGrid( u, step ); }
|
|
|
|
DbU::Unit getOnCustomGrid3 ( DbU::Unit u, DbU::Unit step, long mode )
|
|
{ return DbU::getOnCustomGrid( u, step, (DbU::SnapMode)mode ); }
|
|
|
|
DbU::Unit getOnPhysicalGrid1 ( DbU::Unit u )
|
|
{ return DbU::getOnPhysicalGrid( u ); }
|
|
|
|
DbU::Unit getOnPhysicalGrid2 ( DbU::Unit u, long mode )
|
|
{ return DbU::getOnPhysicalGrid( u, (DbU::SnapMode)mode ); }
|
|
|
|
DbU::Unit getOnRealSnapGrid1 ( DbU::Unit u )
|
|
{ return DbU::getOnRealSnapGrid( u ); }
|
|
|
|
DbU::Unit getOnRealSnapGrid2 ( DbU::Unit u, long snap )
|
|
{ return DbU::getOnRealSnapGrid( u, (DbU::SnapMode)snap ); }
|
|
|
|
DbU::Unit getOnSymbolicSnapGrid1 ( DbU::Unit u )
|
|
{ return DbU::getOnSymbolicSnapGrid( u ); }
|
|
|
|
DbU::Unit getOnSymbolicSnapGrid2 ( DbU::Unit u, long snap )
|
|
{ return DbU::getOnSymbolicSnapGrid( u, (DbU::SnapMode)snap ); }
|
|
|
|
std::string getValueString1 ( DbU::Unit u ) { return DbU::getValueString( u ); }
|
|
std::string getValueString2 ( DbU::Unit u, long mode ) { return DbU::getValueString( u, mode ); }
|
|
|
|
void setStringMode1 ( long mode ) { DbU::setStringMode( mode ); }
|
|
void setStringMode2 ( long mode, long power ) { DbU::setStringMode( mode, (DbU::UnitPower)power ); }
|
|
|
|
|
|
// Python methods.
|
|
|
|
static PyObject* PyDbU_fromDb ( PyObject*, PyObject* args )
|
|
{ return callFunction("DbU.fromDb",&DbU::fromDb,args); }
|
|
|
|
static PyObject* PyDbU_fromGrid ( PyObject*, PyObject* args )
|
|
{
|
|
PyObject* rvalue = callFunction("DbU.fromGrid",&fromGridDouble,args);
|
|
if (not rvalue) rvalue = callFunction("DbU.fromGrid",&fromGridLong,args);
|
|
return rvalue;
|
|
}
|
|
|
|
static PyObject* PyDbU_fromLambda ( PyObject*, PyObject* args )
|
|
{
|
|
PyObject* rvalue = callFunction("DbU.fromLambda",&fromLambdaDouble,args);
|
|
if (not rvalue) rvalue = callFunction("DbU.fromLambda",&fromLambdaLong,args);
|
|
return rvalue;
|
|
}
|
|
|
|
static PyObject* PyDbU_fromPhysical ( PyObject*, PyObject* args )
|
|
{ return callFunction("DbU.fromPhysical",&DbU::fromPhysical,args); }
|
|
|
|
static PyObject* PyDbU_getPrecision ( PyObject*, PyObject* args )
|
|
{ return callFunction("DbU.getPrecision",&DbU::getPrecision,args); }
|
|
|
|
static PyObject* PyDbU_getMaximalPrecision ( PyObject*, PyObject* args )
|
|
{ return callFunction("DbU.getMaximalPrecision",&DbU::getMaximalPrecision,args); }
|
|
|
|
static PyObject* PyDbU_getResolution ( PyObject*, PyObject* args )
|
|
{ return callFunction("DbU.getResolution",&DbU::getResolution,args); }
|
|
|
|
static PyObject* PyDbU_setPrecision ( PyObject*, PyObject* args )
|
|
{ return callFunction("DbU.setPrecision",&setPrecision1,args); }
|
|
|
|
static PyObject* PyDbU_getPolygonStep ( PyObject*, PyObject* args )
|
|
{ return callFunction("DbU.getPolygonStep",&DbU::getPolygonStep,args); }
|
|
|
|
static PyObject* PyDbU_setPolygonStep ( PyObject*, PyObject* args )
|
|
{ return callFunction("DbU.setPolygonStep",&DbU::setPolygonStep,args); }
|
|
|
|
static PyObject* PyDbU_getUnitPower ( PyObject*, PyObject* args )
|
|
{ return callFunction("DbU.getUnitPower",&DbU::getUnitPower,args); }
|
|
|
|
static PyObject* PyDbU_setPhysicalsPerGrid ( PyObject*, PyObject* args )
|
|
{ return callFunction("DbU.setPhysicalsPerGrid",&DbU::setPhysicalsPerGrid,args); }
|
|
|
|
static PyObject* PyDbU_getPhysicalsPerGrid ( PyObject*, PyObject* args )
|
|
{ return callFunction("DbU.getPhysicalsPerGrid",&DbU::getPhysicalsPerGrid,args); }
|
|
|
|
static PyObject* PyDbU_physicalToGrid ( PyObject*, PyObject* args )
|
|
{ return callFunction("DbU.physicalToGrid",&DbU::physicalToGrid,args); }
|
|
|
|
static PyObject* PyDbU_setGridsPerLambda ( PyObject*, PyObject* args )
|
|
{ return callFunction("DbU.setGridsPerLambda",&setGridsPerLambda1,args); }
|
|
|
|
static PyObject* PyDbU_getGridsPerLambda ( PyObject*, PyObject* args )
|
|
{ return callFunction("DbU.getGridsPerLambda",&DbU::getGridsPerLambda,args); }
|
|
|
|
static PyObject* PyDbU_getRealSnapGridStep ( PyObject*, PyObject* args )
|
|
{ return callFunction("DbU.getRealSnapGridStep",&DbU::getRealSnapGridStep,args); }
|
|
|
|
static PyObject* PyDbU_getOnRealSnapGrid ( PyObject*, PyObject* args )
|
|
{
|
|
PyObject* rvalue = callFunction("DbU.getOnRealSnapGrid",&getOnRealSnapGrid2,args);
|
|
if (not rvalue) rvalue = callFunction("DbU.getOnRealSnapGrid",&getOnRealSnapGrid1,args);
|
|
return rvalue;
|
|
}
|
|
|
|
static PyObject* PyDbU_setRealSnapGridStep ( PyObject*, PyObject* args )
|
|
{ return callFunction("DbU.setRealSnapGridStep",&DbU::setRealSnapGridStep,args); }
|
|
|
|
static PyObject* PyDbU_getSymbolicSnapGridStep ( PyObject*, PyObject* args )
|
|
{ return callFunction("DbU.getSymbolicSnapGridStep",&DbU::getSymbolicSnapGridStep,args); }
|
|
|
|
static PyObject* PyDbU_getOnSymbolicSnapGrid ( PyObject*, PyObject* args )
|
|
{
|
|
PyObject* rvalue = callFunction("DbU.getOnSymbolicSnapGrid",&getOnSymbolicSnapGrid2,args);
|
|
if (not rvalue) rvalue = callFunction("DbU.getOnSymbolicSnapGrid",&getOnSymbolicSnapGrid1,args);
|
|
return rvalue;
|
|
}
|
|
|
|
static PyObject* PyDbU_setSymbolicSnapGridStep ( PyObject*, PyObject* args )
|
|
{ return callFunction("DbU.setSymbolicSnapGridStep",&DbU::setSymbolicSnapGridStep,args); }
|
|
|
|
static PyObject* PyDbU_getOnCustomGrid ( PyObject*, PyObject* args )
|
|
{
|
|
PyObject* rvalue = callFunction("DbU.getOnCustomGrid",&getOnCustomGrid3,args);
|
|
if (not rvalue) rvalue = callFunction("DbU.getOnCustomGrid",&getOnCustomGrid2,args);
|
|
return rvalue;
|
|
}
|
|
|
|
static PyObject* PyDbU_getOnPhysicalGrid ( PyObject*, PyObject* args )
|
|
{
|
|
PyObject* rvalue = callFunction("DbU.getOnPhysicalGrid",&getOnPhysicalGrid2,args);
|
|
if (not rvalue) rvalue = callFunction("DbU.getOnPhysicalGrid",&getOnPhysicalGrid1,args);
|
|
return rvalue;
|
|
}
|
|
|
|
static PyObject* PyDbU_toDb ( PyObject*, PyObject* args )
|
|
{ return callFunction("DbU.toDb",&DbU::toDb,args); }
|
|
|
|
static PyObject* PyDbU_toGrid ( PyObject*, PyObject* args )
|
|
{
|
|
PyObject* rvalue = callFunction("DbU.toGrid",&toGridDouble,args);
|
|
if (not rvalue) rvalue = callFunction("DbU.toGrid",&toGridLong,args);
|
|
return rvalue;
|
|
}
|
|
|
|
static PyObject* PyDbU_toLambda ( PyObject*, PyObject* args )
|
|
{
|
|
PyObject* rvalue = callFunction("DbU.toLambda",&toLambdaDouble,args);
|
|
if (not rvalue) rvalue = callFunction("DbU.toLambda",&toLambdaLong,args);
|
|
return rvalue;
|
|
}
|
|
|
|
static PyObject* PyDbU_toPhysical ( PyObject*, PyObject* args )
|
|
{
|
|
PyObject* rvalue = callFunction("DbU.toPhysical",&toPhysicalDouble,args);
|
|
if (not rvalue) rvalue = callFunction("DbU.toPhysical",&toPhysicalLong,args);
|
|
return rvalue;
|
|
}
|
|
|
|
static PyObject* PyDbU_getValueString ( PyObject*, PyObject* args )
|
|
{
|
|
PyObject* rvalue = callFunction("DbU.getValueString",&getValueString2,args);
|
|
if (not rvalue) rvalue = callFunction("DbU.getValueString",&getValueString1,args);
|
|
return rvalue;
|
|
}
|
|
|
|
static PyObject* PyDbU_setStringMode ( PyObject*, PyObject* args )
|
|
{
|
|
PyObject* rvalue = callFunction("DbU.setStringMode",&setStringMode2,args);
|
|
if (not rvalue) rvalue = callFunction("DbU.setStringMode",&setStringMode1,args);
|
|
return rvalue;
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------
|
|
// PyDbU Method table.
|
|
|
|
|
|
PyMethodDef PyDbU_Methods[] =
|
|
// Translate from user length to DbU.
|
|
{ { "fromDb" , (PyCFunction)PyDbU_fromDb , METH_VARARGS|METH_STATIC
|
|
, "Convert a raw unit into a DbU (C++ DbU::fromDb())." }
|
|
, { "fromGrid" , (PyCFunction)PyDbU_fromGrid , METH_VARARGS|METH_STATIC
|
|
, "Convert a length in grid step into a DbU (C++ DbU::fromGrid())." }
|
|
, { "fromLambda" , (PyCFunction)PyDbU_fromLambda , METH_VARARGS|METH_STATIC
|
|
, "Convert a length in lambda into a DbU (C++ DbU::fromLambda())." }
|
|
, { "fromPhysical" , (PyCFunction)PyDbU_fromPhysical , METH_VARARGS|METH_STATIC
|
|
, "Convert a physical length into a DbU (C++ DbU::fromPhysical())." }
|
|
// Precision & Resolution Managment.
|
|
, { "getPrecision" , (PyCFunction)PyDbU_getPrecision , METH_NOARGS|METH_STATIC
|
|
, "Sets the precision, the fixed point for rounding computations." }
|
|
, { "getMaximalPrecision" , (PyCFunction)PyDbU_getMaximalPrecision , METH_NOARGS|METH_STATIC
|
|
, "Returns the maximum allowed precision." }
|
|
, { "getResolution" , (PyCFunction)PyDbU_getResolution , METH_NOARGS|METH_STATIC
|
|
, "Get the smallest manageable unit." }
|
|
, { "setPrecision" , (PyCFunction)PyDbU_setPrecision , METH_VARARGS|METH_STATIC
|
|
, "Sets the precision, the fixed point for rounding computations." }
|
|
// Founder Grid Managment.
|
|
, { "getUnitPower" , (PyCFunction)PyDbU_getUnitPower , METH_VARARGS|METH_STATIC
|
|
, "Returns the numerical value associated to the symbolic power." }
|
|
, { "setPhysicalsPerGrid" , (PyCFunction)PyDbU_setPhysicalsPerGrid , METH_VARARGS|METH_STATIC
|
|
, "Set the physical length represented by exactly one unit." }
|
|
, { "getPhysicalsPerGrid" , (PyCFunction)PyDbU_getPhysicalsPerGrid , METH_NOARGS|METH_STATIC
|
|
, "Returns the physical length represented by exactly one unit." }
|
|
, { "physicalToGrid" , (PyCFunction)PyDbU_physicalToGrid , METH_VARARGS|METH_STATIC
|
|
, "Compute the number of grid units representing that physical length." }
|
|
// Lambda Managment.
|
|
, { "setGridsPerLambda" , (PyCFunction)PyDbU_setGridsPerLambda , METH_VARARGS|METH_STATIC
|
|
, "Set the numbers of grid units in one lambda." }
|
|
, { "getGridsPerLambda" , (PyCFunction)PyDbU_getGridsPerLambda , METH_NOARGS|METH_STATIC
|
|
, "Returns the physical length represented by exactly one unit." }
|
|
// Snap Grid Managment.
|
|
, { "getRealSnapGridStep" , (PyCFunction)PyDbU_getRealSnapGridStep , METH_NOARGS|METH_STATIC
|
|
, "Returns the step of the real snap grid." }
|
|
, { "getOnRealSnapGrid" , (PyCFunction)PyDbU_getOnRealSnapGrid , METH_VARARGS|METH_STATIC
|
|
, "Get a real snap grid position from this one." }
|
|
, { "setRealSnapGridStep" , (PyCFunction)PyDbU_setRealSnapGridStep , METH_VARARGS|METH_STATIC
|
|
, "Sets the real snap grid step." }
|
|
, { "getSymbolicSnapGridStep", (PyCFunction)PyDbU_getSymbolicSnapGridStep, METH_NOARGS|METH_STATIC
|
|
, "Returns the step of the symbolic snap grid." }
|
|
, { "getOnSymbolicSnapGrid" , (PyCFunction)PyDbU_getOnSymbolicSnapGrid , METH_VARARGS|METH_STATIC
|
|
, "Get a symbolic snap grid position from this one." }
|
|
, { "setSymbolicSnapGridStep", (PyCFunction)PyDbU_setSymbolicSnapGridStep, METH_VARARGS|METH_STATIC
|
|
, "Sets the symbolic snap grid step." }
|
|
, { "getOnCustomGrid" , (PyCFunction)PyDbU_getOnCustomGrid , METH_VARARGS|METH_STATIC
|
|
, "Get a custom snap grid position from this one." }
|
|
, { "getOnPhysicalGrid" , (PyCFunction)PyDbU_getOnPhysicalGrid , METH_VARARGS|METH_STATIC
|
|
, "Get a physical grid position from this one." }
|
|
// Convert from DbU to various units (grid,lambda,physical).
|
|
, { "toDb" , (PyCFunction)PyDbU_toDb , METH_VARARGS|METH_STATIC
|
|
, "Convert a DbU into raw unit (C++ DbU::getDb())." }
|
|
, { "toGrid" , (PyCFunction)PyDbU_toGrid , METH_VARARGS|METH_STATIC
|
|
, "Convert a DbU into grid length (C++ DbU::getGrid())." }
|
|
, { "toLambda" , (PyCFunction)PyDbU_toLambda , METH_VARARGS|METH_STATIC
|
|
, "Convert a DbU into lambda length (C++ DbU::getLambda())." }
|
|
, { "toPhysical" , (PyCFunction)PyDbU_toPhysical , METH_VARARGS|METH_STATIC
|
|
, "Convert a DbU into a physcal length (metric system, C++ DbU::getPhysical())." }
|
|
, { "getValueString" , (PyCFunction)PyDbU_getValueString , METH_VARARGS|METH_STATIC
|
|
, "Convert a DbU into a human readable string." }
|
|
, { "setStringMode" , (PyCFunction)PyDbU_setStringMode , METH_VARARGS|METH_STATIC
|
|
, "Tells what unit to use when converting a DbU into a string." }
|
|
// Polygon Step Managment.
|
|
, { "setPolygonStep" , (PyCFunction)PyDbU_setPolygonStep , METH_VARARGS|METH_STATIC
|
|
, "Set the approximation step for Polygons." }
|
|
, { "getPolygonStep" , (PyCFunction)PyDbU_getPolygonStep , METH_NOARGS|METH_STATIC
|
|
, "Returns the approximation step used for Polygons." }
|
|
, {NULL, NULL, 0, NULL} /* sentinel */
|
|
};
|
|
|
|
|
|
} // extern "C".
|
|
|
|
} // Isobar3 namespace.
|