avtText2DColleague::avtText2DColleague(VisWindowColleagueProxy &m)
: avtAnnotationColleague(m)
{
useForegroundForTextColor = true;
addedToRenderer = false;
textFormatString = 0;
textString = 0;
currentTime = initialTime;
currentCycle = initialCycle;
//
// Create and position the actor.
//
textActor = vtkVisItTextActor::New();
textActor->SetTextScaleMode(vtkTextActor::TEXT_SCALE_MODE_VIEWPORT);
textActor->SetTextHeight(0.03);
SetText("2D text annotation");
vtkCoordinate *pos = textActor->GetPositionCoordinate();
pos->SetCoordinateSystemToNormalizedViewport();
pos->SetValue(0.5, 0.5, 0.);
// Make sure that the actor initially has the right fg color.
double fgColor[3];
mediator.GetForegroundColor(fgColor);
SetForegroundColor(fgColor[0], fgColor[1], fgColor[2]);
textActor->GetTextProperty()->SetOpacity(1.);
// Store the foreground color into the text color.
int ifgColor[3];
ifgColor[0] = int((float)fgColor[0] * 255.f);
ifgColor[1] = int((float)fgColor[1] * 255.f);
ifgColor[2] = int((float)fgColor[2] * 255.f);
textColor = ColorAttribute(ifgColor[0], ifgColor[1], ifgColor[2], 255);
}
void
WellBoreAttributes::EnlargeMultiColor(int newSize)
{
// Add any colors that are needed to the end of the vector to ensure
// we have the right number of elements in the vector.
if(newSize > 0)
{
unsigned char *rgb = new unsigned char[newSize * 4];
// If it's a discrete color table, just use the colors of
// the control points. Otherwise, sample the color table.
if(defaultPalette.GetDiscreteFlag())
{
int nColors = defaultPalette.GetNumControlPoints();
for(int i = 0, index = 0; i < newSize; ++i, index += 4)
{
int j = i % nColors;
const ColorControlPoint &ccp = defaultPalette.operator[](j);
const unsigned char *c = ccp.GetColors();
rgb[index] = c[0];
rgb[index+1] = c[1];
rgb[index+2] = c[2];
rgb[index+3] = c[3];
}
}
else
{
defaultPalette.GetColors(rgb, newSize);
}
bool modified = false;
for(int i = 0; i < newSize; ++i)
{
int j = i * 4;
if(i < multiColor.GetNumColors())
{
if(!ColorIsChanged(i))
{
ColorAttribute &ca = multiColor.GetColors(i);
ca.SetRgba(int(rgb[j]), int(rgb[j+1]), int(rgb[j+2]),int(rgb[j+3]));
}
}
else
{
multiColor.AddColors(ColorAttribute(rgb[j],
rgb[j+1],
rgb[j+2],
rgb[j+3]));
}
modified = true;
}
delete [] rgb;
// If the multiColor vector was modified, select it.
if(modified)
SelectMultiColor();
}
}
avtLegendAttributesColleague::avtLegendAttributesColleague(
VisWindowColleagueProxy &m) : avtAnnotationColleague(m), atts()
{
// Populate atts with some legend defaults.
SetBool(atts, LEGEND_MANAGE_POSITION, true);
SetBool(atts, LEGEND_DRAW_BOX, false);
SetBool(atts, LEGEND_DRAW_LABELS, false);
SetBool(atts, LEGEND_ORIENTATION0, false);
SetBool(atts, LEGEND_ORIENTATION1, false);
SetBool(atts, LEGEND_DRAW_TITLE, true);
SetBool(atts, LEGEND_DRAW_MINMAX, true);
SetBool(atts, LEGEND_CONTROL_TICKS, true);
SetBool(atts, LEGEND_MINMAX_INCLUSIVE, true);
SetBool(atts, LEGEND_DRAW_VALUES, true);
// Set the format string for the legend into the text.
stringVector text;
text.push_back("%# -9.4g");
atts.SetText(text);
// Set the default position.
const double defaultPosition[2] = {0.05, 0.9};
atts.SetPosition(defaultPosition);
// Set the default scale.
const double defaultScale[2] = {1.,1.};
atts.SetPosition2(defaultScale);
// Set the default font height.
atts.SetDoubleAttribute1(0.015);
// Set the default bounding box color.
atts.SetColor1(ColorAttribute(0,0,0,50));
// Set the default font properties.
atts.SetFontFamily(AnnotationObject::Arial);
atts.SetFontBold(false);
atts.SetFontItalic(false);
atts.SetFontShadow(false);
// Set the default number of ticks
atts.SetIntAttribute2(5);
// Set the default legend type to variable
atts.SetIntAttribute3(0);
}
/*static*/ PyObject *
MultiCurveAttributes_SetMultiColor(PyObject *self, PyObject *args)
{
MultiCurveAttributesObject *obj = (MultiCurveAttributesObject *)self;
PyObject *pyobj = NULL;
ColorAttributeList &cL = obj->data->GetMultiColor();
int index = 0;
int c[4] = {0,0,0,255};
bool setTheColor = true;
if(!PyArg_ParseTuple(args, "iiiii", &index, &c[0], &c[1], &c[2], &c[3]))
{
if(!PyArg_ParseTuple(args, "iiii", &index, &c[0], &c[1], &c[2]))
{
double dr, dg, db, da;
if(PyArg_ParseTuple(args, "idddd", &index, &dr, &dg, &db, &da))
{
c[0] = int(dr);
c[1] = int(dg);
c[2] = int(db);
c[3] = int(da);
}
else if(PyArg_ParseTuple(args, "iddd", &index, &dr, &dg, &db))
{
c[0] = int(dr);
c[1] = int(dg);
c[2] = int(db);
c[3] = 255;
}
else
{
if(!PyArg_ParseTuple(args, "iO", &index, &pyobj))
{
if(PyArg_ParseTuple(args, "O", &pyobj))
{
setTheColor = false;
if(PyTuple_Check(pyobj))
{
// Make sure that the tuple is the right size.
if(PyTuple_Size(pyobj) < cL.GetNumColors())
return NULL;
// Make sure that the tuple is the right size.
bool badInput = false;
int *C = new int[4 * cL.GetNumColors()];
for(int i = 0; i < PyTuple_Size(pyobj) && !badInput; ++i)
{
PyObject *item = PyTuple_GET_ITEM(pyobj, i);
if(PyTuple_Check(item) &&
PyTuple_Size(item) == 3 || PyTuple_Size(item) == 4)
{
C[i*4] = 0;
C[i*4+1] = 0;
C[i*4+2] = 0;
C[i*4+3] = 255;
for(int j = 0; j < PyTuple_Size(item) && !badInput; ++j)
{
PyObject *colorcomp = PyTuple_GET_ITEM(item, j);
if(PyInt_Check(colorcomp))
C[i*4+j] = int(PyInt_AS_LONG(colorcomp));
else if(PyFloat_Check(colorcomp))
C[i*4+j] = int(PyFloat_AS_DOUBLE(colorcomp));
else
badInput = true;
}
}
else
badInput = true;
}
if(badInput)
{
delete [] C;
return NULL;
}
for(int i = 0; i < cL.GetNumColors(); ++i)
cL[i].SetRgba(C[i*4], C[i*4+1], C[i*4+2], C[i*4+3]);
delete [] C;
}
else if(PyList_Check(pyobj))
{
// Make sure that the list is the right size.
if(PyList_Size(pyobj) < cL.GetNumColors())
return NULL;
// Make sure that the tuple is the right size.
bool badInput = false;
int *C = new int[4 * cL.GetNumColors()];
for(int i = 0; i < PyList_Size(pyobj) && !badInput; ++i)
{
PyObject *item = PyList_GET_ITEM(pyobj, i);
if(PyTuple_Check(item) &&
PyTuple_Size(item) == 3 || PyTuple_Size(item) == 4)
{
C[i*4] = 0;
C[i*4+1] = 0;
C[i*4+2] = 0;
C[i*4+3] = 255;
for(int j = 0; j < PyTuple_Size(item) && !badInput; ++j)
{
PyObject *colorcomp = PyTuple_GET_ITEM(item, j);
if(PyInt_Check(colorcomp))
C[i*4+j] = int(PyInt_AS_LONG(colorcomp));
else if(PyFloat_Check(colorcomp))
C[i*4+j] = int(PyFloat_AS_DOUBLE(colorcomp));
else
badInput = true;
}
}
else
badInput = true;
}
if(badInput)
{
delete [] C;
return NULL;
}
for(int i = 0; i < cL.GetNumColors(); ++i)
cL[i].SetRgba(C[i*4], C[i*4+1], C[i*4+2], C[i*4+3]);
delete [] C;
}
else
return NULL;
}
}
else
{
if(!PyTuple_Check(pyobj))
return NULL;
// Make sure that the tuple is the right size.
if(PyTuple_Size(pyobj) < 3 || PyTuple_Size(pyobj) > 4)
return NULL;
// Make sure that all elements in the tuple are ints.
for(int i = 0; i < PyTuple_Size(pyobj); ++i)
{
PyObject *item = PyTuple_GET_ITEM(pyobj, i);
if(PyInt_Check(item))
c[i] = int(PyInt_AS_LONG(PyTuple_GET_ITEM(pyobj, i)));
else if(PyFloat_Check(item))
c[i] = int(PyFloat_AS_DOUBLE(PyTuple_GET_ITEM(pyobj, i)));
else
return NULL;
}
}
}
}
PyErr_Clear();
}
if(index < 0 || index >= cL.GetNumColors())
return NULL;
// Set the color in the object.
if(setTheColor)
cL[index] = ColorAttribute(c[0], c[1], c[2], c[3]);
cL.SelectColors();
obj->data->SelectMultiColor();
Py_INCREF(Py_None);
return Py_None;
}
