kindred/create
1
1
Fork 0
Code Issues 37 Pull Requests Actions Packages Projects 9 Releases 2 Wiki Activity

Integrate Werners & Jans double branch

Browse Source 
Move from float to double
Further suggestions for float -> double move
Moved Tools2D from float to double
More suggestions for float->double move from Gui subdirectory
Changes to FEM constraint visuals for float->double move
Suggested changes for float -> double move
Suggestions for Part module moving float -> double
This commit is contained in:
jriegel
2013-09-22 21:55:11 +02:00
parent 78ba09a490
commit 00ea24e07e
64 changed files with 719 additions and 589 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/App/Annotation.cpp
View File

@@ -36,7 +36,7 @@ PROPERTY_SOURCE(App::Annotation, App::DocumentObject)
Annotation::Annotation()
{
ADD_PROPERTY(LabelText ,(""));
ADD_PROPERTY(Position,(Base::Vector3f()));
ADD_PROPERTY(Position,(Base::Vector3d()));
}
Annotation::~Annotation()
@@ -51,8 +51,8 @@ PROPERTY_SOURCE(App::AnnotationLabel, App::DocumentObject)
AnnotationLabel::AnnotationLabel()
{
ADD_PROPERTY_TYPE(LabelText,(""),"Label",Prop_Output,"Text label of the annotation");
ADD_PROPERTY_TYPE(BasePosition,(Base::Vector3f()),"Label",Prop_Output,"Base position");
ADD_PROPERTY_TYPE(TextPosition,(Base::Vector3f()),"Label",Prop_Output,"Text position");
ADD_PROPERTY_TYPE(BasePosition,(Base::Vector3d()),"Label",Prop_Output,"Base position");
ADD_PROPERTY_TYPE(TextPosition,(Base::Vector3d()),"Label",Prop_Output,"Text position");
}
AnnotationLabel::~AnnotationLabel()

6
src/App/MeasureDistance.cpp
View File

@@ -35,9 +35,9 @@ PROPERTY_SOURCE(App::MeasureDistance, App::DocumentObject)
MeasureDistance::MeasureDistance()
{
ADD_PROPERTY_TYPE(P1,(Base::Vector3f()),"Measurement",Prop_None,"First point of measurement");
ADD_PROPERTY_TYPE(P2,(Base::Vector3f()),"Measurement",Prop_None,"Second point of measurement");
ADD_PROPERTY_TYPE(Distance,(0.0f) ,"Measurement",App::PropertyType(Prop_ReadOnly|Prop_Output),
ADD_PROPERTY_TYPE(P1,(Base::Vector3d()),"Measurement",Prop_None,"First point of measurement");
ADD_PROPERTY_TYPE(P2,(Base::Vector3d()),"Measurement",Prop_None,"Second point of measurement");
ADD_PROPERTY_TYPE(Distance,(0.0) ,"Measurement",App::PropertyType(Prop_ReadOnly|Prop_Output),
"Distance between the points");
}

82
src/App/PropertyGeo.cpp
View File

@@ -75,21 +75,21 @@ PropertyVector::~PropertyVector()
// Base class implementer
void PropertyVector::setValue(const Base::Vector3f &vec)
void PropertyVector::setValue(const Base::Vector3d &vec)
{
aboutToSetValue();
_cVec=vec;
hasSetValue();
}
void PropertyVector::setValue(float x, float y, float z)
void PropertyVector::setValue(double x, double y, double z)
{
aboutToSetValue();
_cVec=Vector3f(x,y,z);
_cVec.Set(x,y,z);
hasSetValue();
}
const Base::Vector3f & PropertyVector::getValue(void)const
const Base::Vector3d & PropertyVector::getValue(void)const
{
return _cVec;
}
@@ -104,34 +104,33 @@ void PropertyVector::setPyObject(PyObject *value)
if (PyObject_TypeCheck(value, &(Base::VectorPy::Type))) {
Base::VectorPy *pcObject = static_cast<Base::VectorPy*>(value);
Base::Vector3d* val = pcObject->getVectorPtr();
Base::Vector3f vec((float)val->x,(float)val->y,(float)val->z);
setValue(vec);
setValue(*val);
}
else if (PyTuple_Check(value)&&PyTuple_Size(value)==3) {
PyObject* item;
Base::Vector3f cVec;
Base::Vector3d cVec;
// x
item = PyTuple_GetItem(value,0);
if (PyFloat_Check(item))
cVec.x = (float)PyFloat_AsDouble(item);
cVec.x = PyFloat_AsDouble(item);
else if (PyInt_Check(item))
cVec.x = (float)PyInt_AsLong(item);
cVec.x = (double)PyInt_AsLong(item);
else
throw Base::TypeError("Not allowed type used in tuple (float expected)...");
// y
item = PyTuple_GetItem(value,1);
if (PyFloat_Check(item))
cVec.y = (float)PyFloat_AsDouble(item);
cVec.y = PyFloat_AsDouble(item);
else if (PyInt_Check(item))
cVec.y = (float)PyInt_AsLong(item);
cVec.y = (double)PyInt_AsLong(item);
else
throw Base::TypeError("Not allowed type used in tuple (float expected)...");
// z
item = PyTuple_GetItem(value,2);
if (PyFloat_Check(item))
cVec.z = (float)PyFloat_AsDouble(item);
cVec.z = PyFloat_AsDouble(item);
else if (PyInt_Check(item))
cVec.z = (float)PyInt_AsLong(item);
cVec.z = (double)PyInt_AsLong(item);
else
throw Base::TypeError("Not allowed type used in tuple (float expected)...");
setValue( cVec );
@@ -154,9 +153,9 @@ void PropertyVector::Restore(Base::XMLReader &reader)
reader.readElement("PropertyVector");
// get the value of my Attribute
aboutToSetValue();
_cVec.x = (float)reader.getAttributeAsFloat("valueX");
_cVec.y = (float)reader.getAttributeAsFloat("valueY");
_cVec.z = (float)reader.getAttributeAsFloat("valueZ");
_cVec.x = reader.getAttributeAsFloat("valueX");
_cVec.y = reader.getAttributeAsFloat("valueY");
_cVec.z = reader.getAttributeAsFloat("valueZ");
hasSetValue();
}
@@ -208,7 +207,7 @@ int PropertyVectorList::getSize(void) const
return static_cast<int>(_lValueList.size());
}
void PropertyVectorList::setValue(const Base::Vector3f& lValue)
void PropertyVectorList::setValue(const Base::Vector3d& lValue)
{
aboutToSetValue();
_lValueList.resize(1);
@@ -216,7 +215,7 @@ void PropertyVectorList::setValue(const Base::Vector3f& lValue)
hasSetValue();
}
void PropertyVectorList::setValue(float x, float y, float z)
void PropertyVectorList::setValue(double x, double y, double z)
{
aboutToSetValue();
_lValueList.resize(1);
@@ -224,7 +223,7 @@ void PropertyVectorList::setValue(float x, float y, float z)
hasSetValue();
}
void PropertyVectorList::setValues(const std::vector<Base::Vector3f>& values)
void PropertyVectorList::setValues(const std::vector<Base::Vector3d>& values)
{
aboutToSetValue();
_lValueList = values;
@@ -245,7 +244,7 @@ void PropertyVectorList::setPyObject(PyObject *value)
{
if (PyList_Check(value)) {
Py_ssize_t nSize = PyList_Size(value);
std::vector<Base::Vector3f> values;
std::vector<Base::Vector3d> values;
values.resize(nSize);
for (Py_ssize_t i=0; i<nSize;++i) {
@@ -260,8 +259,7 @@ void PropertyVectorList::setPyObject(PyObject *value)
else if (PyObject_TypeCheck(value, &(VectorPy::Type))) {
Base::VectorPy *pcObject = static_cast<Base::VectorPy*>(value);
Base::Vector3d* val = pcObject->getVectorPtr();
Base::Vector3f vec((float)val->x,(float)val->y,(float)val->z);
setValue(vec);
setValue(*val);
}
else if (PyTuple_Check(value) && PyTuple_Size(value) == 3) {
PropertyVector val;
@@ -298,7 +296,7 @@ void PropertyVectorList::SaveDocFile (Base::Writer &writer) const
Base::OutputStream str(writer.Stream());
uint32_t uCt = (uint32_t)getSize();
str << uCt;
for (std::vector<Base::Vector3f>::const_iterator it = _lValueList.begin(); it != _lValueList.end(); ++it) {
for (std::vector<Base::Vector3d>::const_iterator it = _lValueList.begin(); it != _lValueList.end(); ++it) {
str << it->x << it->y << it->z;
}
}
@@ -308,8 +306,8 @@ void PropertyVectorList::RestoreDocFile(Base::Reader &reader)
Base::InputStream str(reader);
uint32_t uCt=0;
str >> uCt;
std::vector<Base::Vector3f> values(uCt);
for (std::vector<Base::Vector3f>::iterator it = values.begin(); it != values.end(); ++it) {
std::vector<Base::Vector3d> values(uCt);
for (std::vector<Base::Vector3d>::iterator it = values.begin(); it != values.end(); ++it) {
str >> it->x >> it->y >> it->z;
}
setValues(values);
@@ -331,7 +329,7 @@ void PropertyVectorList::Paste(const Property &from)
unsigned int PropertyVectorList::getMemSize (void) const
{
return static_cast<unsigned int>(_lValueList.size() * sizeof(Base::Vector3f));
return static_cast<unsigned int>(_lValueList.size() * sizeof(Base::Vector3d));
}
//**************************************************************************
@@ -425,25 +423,25 @@ void PropertyMatrix::Restore(Base::XMLReader &reader)
reader.readElement("PropertyMatrix");
// get the value of my Attribute
aboutToSetValue();
_cMat[0][0] = (float)reader.getAttributeAsFloat("a11");
_cMat[0][1] = (float)reader.getAttributeAsFloat("a12");
_cMat[0][2] = (float)reader.getAttributeAsFloat("a13");
_cMat[0][3] = (float)reader.getAttributeAsFloat("a14");
_cMat[0][0] = reader.getAttributeAsFloat("a11");
_cMat[0][1] = reader.getAttributeAsFloat("a12");
_cMat[0][2] = reader.getAttributeAsFloat("a13");
_cMat[0][3] = reader.getAttributeAsFloat("a14");
_cMat[1][0] = (float)reader.getAttributeAsFloat("a21");
_cMat[1][1] = (float)reader.getAttributeAsFloat("a22");
_cMat[1][2] = (float)reader.getAttributeAsFloat("a23");
_cMat[1][3] = (float)reader.getAttributeAsFloat("a24");
_cMat[1][0] = reader.getAttributeAsFloat("a21");
_cMat[1][1] = reader.getAttributeAsFloat("a22");
_cMat[1][2] = reader.getAttributeAsFloat("a23");
_cMat[1][3] = reader.getAttributeAsFloat("a24");
_cMat[2][0] = (float)reader.getAttributeAsFloat("a31");
_cMat[2][1] = (float)reader.getAttributeAsFloat("a32");
_cMat[2][2] = (float)reader.getAttributeAsFloat("a33");
_cMat[2][3] = (float)reader.getAttributeAsFloat("a34");
_cMat[2][0] = reader.getAttributeAsFloat("a31");
_cMat[2][1] = reader.getAttributeAsFloat("a32");
_cMat[2][2] = reader.getAttributeAsFloat("a33");
_cMat[2][3] = reader.getAttributeAsFloat("a34");
_cMat[3][0] = (float)reader.getAttributeAsFloat("a41");
_cMat[3][1] = (float)reader.getAttributeAsFloat("a42");
_cMat[3][2] = (float)reader.getAttributeAsFloat("a43");
_cMat[3][3] = (float)reader.getAttributeAsFloat("a44");
_cMat[3][0] = reader.getAttributeAsFloat("a41");
_cMat[3][1] = reader.getAttributeAsFloat("a42");
_cMat[3][2] = reader.getAttributeAsFloat("a43");
_cMat[3][3] = reader.getAttributeAsFloat("a44");
hasSetValue();
}

24
src/App/PropertyGeo.h
View File

@@ -72,12 +72,12 @@ public:
/** Sets the property
*/
void setValue(const Base::Vector3f &vec);
void setValue(float x, float y, float z);
void setValue(const Base::Vector3d &vec);
void setValue(double x, double y, double z);
/** This method returns a string representation of the property
*/
const Base::Vector3f &getValue(void) const;
const Base::Vector3d &getValue(void) const;
const char* getEditorName(void) const {
return "Gui::PropertyEditor::PropertyVectorItem";
}
@@ -92,11 +92,11 @@ public:
virtual void Paste(const Property &from);
virtual unsigned int getMemSize (void) const {
return sizeof(Base::Vector3f);
return sizeof(Base::Vector3d);
}
private:
Base::Vector3f _cVec;
Base::Vector3d _cVec;
};
@@ -122,21 +122,21 @@ public:
/** Sets the property
*/
void setValue(const Base::Vector3f&);
void setValue(float x, float y, float z);
void setValue(const Base::Vector3d&);
void setValue(double x, double y, double z);
/// index operator
const Base::Vector3f& operator[] (const int idx) const {
const Base::Vector3d& operator[] (const int idx) const {
return _lValueList.operator[] (idx);
}
void set1Value (const int idx, const Base::Vector3f& value) {
void set1Value (const int idx, const Base::Vector3d& value) {
_lValueList.operator[] (idx) = value;
}
void setValues (const std::vector<Base::Vector3f>& values);
void setValues (const std::vector<Base::Vector3d>& values);
const std::vector<Base::Vector3f> &getValues(void) const {
const std::vector<Base::Vector3d> &getValues(void) const {
return _lValueList;
}
@@ -155,7 +155,7 @@ public:
virtual unsigned int getMemSize (void) const;
private:
std::vector<Base::Vector3f> _lValueList;
std::vector<Base::Vector3d> _lValueList;
};
/** Vector properties

32
src/App/PropertyStandard.cpp
View File

@@ -896,14 +896,14 @@ PropertyFloat::~PropertyFloat()
//**************************************************************************
// Base class implementer
void PropertyFloat::setValue(float lValue)
void PropertyFloat::setValue(double lValue)
{
aboutToSetValue();
_dValue=lValue;
hasSetValue();
}
float PropertyFloat::getValue(void) const
double PropertyFloat::getValue(void) const
{
return _dValue;
}
@@ -917,12 +917,12 @@ void PropertyFloat::setPyObject(PyObject *value)
{
if (PyFloat_Check(value)) {
aboutToSetValue();
_dValue = (float) PyFloat_AsDouble(value);
_dValue = PyFloat_AsDouble(value);
hasSetValue();
}
else if(PyInt_Check(value)) {
aboutToSetValue();
_dValue = (float) PyInt_AsLong(value);
_dValue = PyInt_AsLong(value);
hasSetValue();
}
else {
@@ -942,7 +942,7 @@ void PropertyFloat::Restore(Base::XMLReader &reader)
// read my Element
reader.readElement("Float");
// get the value of my Attribute
setValue((float)reader.getAttributeAsFloat("value"));
setValue(reader.getAttributeAsFloat("value"));
}
Property *PropertyFloat::Copy(void) const
@@ -994,7 +994,7 @@ const PropertyFloatConstraint::Constraints* PropertyFloatConstraint::getConstra
void PropertyFloatConstraint::setPyObject(PyObject *value)
{
if (PyFloat_Check(value)) {
float temp = (float)PyFloat_AsDouble(value);
double temp = PyFloat_AsDouble(value);
if (_ConstStruct) {
if (temp > _ConstStruct->UpperBound)
temp = _ConstStruct->UpperBound;
@@ -1007,7 +1007,7 @@ void PropertyFloatConstraint::setPyObject(PyObject *value)
hasSetValue();
}
else if (PyInt_Check(value)) {
float temp = (float)PyInt_AsLong(value);
double temp = (double)PyInt_AsLong(value);
if (_ConstStruct) {
if (temp > _ConstStruct->UpperBound)
temp = _ConstStruct->UpperBound;
@@ -1060,7 +1060,7 @@ int PropertyFloatList::getSize(void) const
return static_cast<int>(_lValueList.size());
}
void PropertyFloatList::setValue(float lValue)
void PropertyFloatList::setValue(double lValue)
{
aboutToSetValue();
_lValueList.resize(1);
@@ -1068,7 +1068,7 @@ void PropertyFloatList::setValue(float lValue)
hasSetValue();
}
void PropertyFloatList::setValues(const std::vector<float>& values)
void PropertyFloatList::setValues(const std::vector<double>& values)
{
aboutToSetValue();
_lValueList = values;
@@ -1087,7 +1087,7 @@ void PropertyFloatList::setPyObject(PyObject *value)
{
if (PyList_Check(value)) {
Py_ssize_t nSize = PyList_Size(value);
std::vector<float> values;
std::vector<double> values;
values.resize(nSize);
for (Py_ssize_t i=0; i<nSize;++i) {
@@ -1098,13 +1098,13 @@ void PropertyFloatList::setPyObject(PyObject *value)
throw Base::TypeError(error);
}
values[i] = (float) PyFloat_AsDouble(item);
values[i] = PyFloat_AsDouble(item);
}
setValues(values);
}
else if (PyFloat_Check(value)) {
setValue((float) PyFloat_AsDouble(value));
setValue(PyFloat_AsDouble(value));
}
else {
std::string error = std::string("type must be float or list of float, not ");
@@ -1145,7 +1145,7 @@ void PropertyFloatList::SaveDocFile (Base::Writer &writer) const
Base::OutputStream str(writer.Stream());
uint32_t uCt = (uint32_t)getSize();
str << uCt;
for (std::vector<float>::const_iterator it = _lValueList.begin(); it != _lValueList.end(); ++it) {
for (std::vector<double>::const_iterator it = _lValueList.begin(); it != _lValueList.end(); ++it) {
str << *it;
}
}
@@ -1155,8 +1155,8 @@ void PropertyFloatList::RestoreDocFile(Base::Reader &reader)
Base::InputStream str(reader);
uint32_t uCt=0;
str >> uCt;
std::vector<float> values(uCt);
for (std::vector<float>::iterator it = values.begin(); it != values.end(); ++it) {
std::vector<double> values(uCt);
for (std::vector<double>::iterator it = values.begin(); it != values.end(); ++it) {
str >> *it;
}
setValues(values);
@@ -1178,7 +1178,7 @@ void PropertyFloatList::Paste(const Property &from)
unsigned int PropertyFloatList::getMemSize (void) const
{
return static_cast<unsigned int>(_lValueList.size() * sizeof(float));
return static_cast<unsigned int>(_lValueList.size() * sizeof(double));
}
//**************************************************************************

22
src/App/PropertyStandard.h
View File

@@ -427,8 +427,8 @@ public:
virtual ~PropertyFloat();
void setValue(float lValue);
float getValue(void) const;
void setValue(double lValue);
double getValue(void) const;
virtual const char* getEditorName(void) const { return "Gui::PropertyEditor::PropertyFloatItem"; }
@@ -441,10 +441,10 @@ public:
virtual Property *Copy(void) const;
virtual void Paste(const Property &from);
virtual unsigned int getMemSize (void) const{return sizeof(float);}
virtual unsigned int getMemSize (void) const{return sizeof(double);}
protected:
float _dValue;
double _dValue;
};
/** Constraint float properties
@@ -475,7 +475,7 @@ public:
//@{
/// the boundary struct
struct Constraints {
float LowerBound, UpperBound, StepSize;
double LowerBound, UpperBound, StepSize;
};
/** setting the boundaries
* This sets the constraint struct. It can be dynamcly
@@ -522,16 +522,16 @@ public:
/** Sets the property
*/
void setValue(float);
void setValue(double);
/// index operator
float operator[] (const int idx) const {return _lValueList.operator[] (idx);}
double operator[] (const int idx) const {return _lValueList.operator[] (idx);}
void set1Value (const int idx, float value){_lValueList.operator[] (idx) = value;}
void setValues (const std::vector<float>& values);
void set1Value (const int idx, double value){_lValueList.operator[] (idx) = value;}
void setValues (const std::vector<double>& values);
const std::vector<float> &getValues(void) const{return _lValueList;}
const std::vector<double> &getValues(void) const{return _lValueList;}
virtual PyObject *getPyObject(void);
virtual void setPyObject(PyObject *);
@@ -547,7 +547,7 @@ public:
virtual unsigned int getMemSize (void) const;
private:
std::vector<float> _lValueList;
std::vector<double> _lValueList;
};

6
src/App/PropertyUnits.cpp
View File

@@ -116,12 +116,12 @@ void PropertyLength::setPyObject(PyObject *value)
setValue(UnitsApi::toDblWithUserPrefs(Length,value));
#else
float val=0.0f;
double val=0.0f;
if (PyFloat_Check(value)) {
val = (float) PyFloat_AsDouble(value);
val = PyFloat_AsDouble(value);
}
else if(PyInt_Check(value)) {
val = (float) PyInt_AsLong(value);
val = (double) PyInt_AsLong(value);
}
else {
std::string error = std::string("type must be float or int, not ");