static void drawScale(drawContext *ctx, PView *p, double xmin, double ymin,
double width, double height, double tic, int horizontal)
{
// use adaptive data if available
PViewData *data = p->getData(true);
PViewOptions *opt = p->getOptions();
if(opt->externalViewIndex >= 0){
opt->tmpMin = opt->externalMin;
opt->tmpMax = opt->externalMax;
}
else if(opt->rangeType == PViewOptions::Custom){
opt->tmpMin = opt->customMin;
opt->tmpMax = opt->customMax;
}
else if(opt->rangeType == PViewOptions::PerTimeStep){
opt->tmpMin = data->getMin(opt->timeStep);
opt->tmpMax = data->getMax(opt->timeStep);
}
else{
opt->tmpMin = data->getMin();
opt->tmpMax = data->getMax();
}
drawScaleBar(p, xmin, ymin, width, height, tic, horizontal);
drawScaleValues(ctx, p, xmin, ymin, width, height, tic, horizontal);
drawScaleLabel(ctx, p, xmin, ymin, width, height, tic, horizontal);
}
double PViewEvaluator::operator()(double x, double y, double z) const
{
PViewData *pvd = _pv->getData();
double value;
bool found = pvd->searchScalar(x, y, z, &value, _step);
// printf("found %d %g %g %g %g\n",found,x,y,value,x*x+y*y);
if(found) return value;
return 1.e22;
}
PViewData *GMSH_PostPlugin::getPossiblyAdaptiveData(PView *view)
{
if(!view) return 0;
PViewData *data = view->getData();
if(data->getAdaptiveData() && data->getNumTimeSteps() > 1)
Msg::Warning("Using adapted data from view '%s': only the current time step (%d/%d) "
"is available to the plugin", view->getData()->getName().c_str(),
view->getOptions()->timeStep, data->getNumTimeSteps());
return view->getData(true);
}
// This version sends VArrays using MPI
static void computeAndSendVertexArrays()
{
// compute...
for(unsigned int i = 0; i < PView::list.size(); i++)
PView::list[i]->fillVertexArrays();
// ...and send
int nbArrays = PView::list.size()* 4;
MPI_Send(&nbArrays, 1, MPI_INT, 0, MPI_GMSH_DATA_READY, MPI_COMM_WORLD);
for(unsigned int i = 0; i < PView::list.size(); i++){
PView *p = PView::list[i];
PViewData *data = p->getData();
PViewOptions *opt = p->getOptions();
double min = data->getMin(), max = data->getMax();
if(opt->rangeType == PViewOptions::PerTimeStep){
min = data->getMin(opt->timeStep);
max = data->getMax(opt->timeStep);
}
VertexArray *va[4] =
{p->va_points, p->va_lines, p->va_triangles, p->va_vectors};
for(int type = 0; type < 4; type++){
if(va[type]){
int len;
char *str = va[type]->toChar
(p->getTag(), data->getName(), type + 1, min, max,
data->getNumTimeSteps(), data->getTime(opt->timeStep),
data->getBoundingBox(), len);
MPI_Send(&len, 1, MPI_INT, 0, MPI_GMSH_VARRAY_LEN, MPI_COMM_WORLD);
MPI_Send(str, len, MPI_CHAR, 0, MPI_GMSH_VARRAY, MPI_COMM_WORLD);
delete [] str;
}
}
}
}
static void computeAndSendVertexArrays(GmshClient *client, bool compute=true)
{
for(unsigned int i = 0; i < PView::list.size(); i++){
PView *p = PView::list[i];
if(compute) p->fillVertexArrays();
PViewData *data = p->getData();
PViewOptions *opt = p->getOptions();
double min = data->getMin(), max = data->getMax();
if(opt->rangeType == PViewOptions::PerTimeStep){
min = data->getMin(opt->timeStep);
max = data->getMax(opt->timeStep);
}
VertexArray *va[4] =
{p->va_points, p->va_lines, p->va_triangles, p->va_vectors};
for(int type = 0; type < 4; type++){
if(va[type]){
int len;
char *str = va[type]->toChar
(p->getTag(), data->getName(), type + 1, min, max,
data->getNumTimeSteps(), data->getTime(opt->timeStep),
data->getBoundingBox(), len);
client->SendMessage(GmshSocket::GMSH_VERTEX_ARRAY, len, str);
delete [] str;
}
}
}
}
// Merge the vertex arrays
static void addToVertexArrays(int length, const char* bytes, int swap)
{
std::string name;
int num, type, numSteps;
double min, max, time, xmin, ymin, zmin, xmax, ymax, zmax;
VertexArray::decodeHeader(length, bytes, swap, name, num, type, min, max,
numSteps, time, xmin, ymin, zmin, xmax, ymax, zmax);
PView *p = PView::list[num - 1];
PViewData *data = p->getData();
VertexArray *varrays[4] =
{p->va_points, p->va_lines, p->va_triangles, p->va_vectors};
VertexArray *va = varrays[type - 1];
if (data->getMin() > min) data->setMin(min);
if (data->getMax() < max) data->setMax(max);
SBoundingBox3d bbox(xmin, ymin, zmin, xmax, ymax, zmax);
SBoundingBox3d bb = data->getBoundingBox();
bb += bbox;
data->setBoundingBox(bb);
if (type == 4) type = 2;
VertexArray* toAdd = new VertexArray(type, 100);
toAdd->fromChar(length, bytes, swap);
va->merge(toAdd);
delete toAdd;
}
static void drawScaleLabel(drawContext *ctx, PView *p, double xmin, double ymin,
double width, double height, double tic, int horizontal)
{
PViewOptions *opt = p->getOptions();
PViewData *data;
// requested by Laurent: but is this really what we should be doing?
if(opt->externalViewIndex >= 0 && opt->externalViewIndex < (int)PView::list.size())
data = PView::list[opt->externalViewIndex]->getData();
else
data = p->getData();
drawContext::global()->setFont(CTX::instance()->glFontEnum,
CTX::instance()->glFontSize);
double font_h = drawContext::global()->getStringHeight();
char label[1024];
int nt = data->getNumTimeSteps();
if((opt->showTime == 1 && nt > 1) || opt->showTime == 2){
char tmp[256];
sprintf(tmp, opt->format.c_str(), data->getTime(opt->timeStep));
sprintf(label, "%s (%s)", data->getName().c_str(), tmp);
}
else if((opt->showTime == 3 && nt > 1) || opt->showTime == 4){
sprintf(label, "%s (%d/%d)", data->getName().c_str(), opt->timeStep,
data->getNumTimeSteps() - 1);
}
else
sprintf(label, "%s", data->getName().c_str());
if(horizontal){
glRasterPos2d(xmin + width / 2., ymin + height + tic + 1.4 * font_h);
ctx->drawString(label, CTX::instance()->glFontTitle,
CTX::instance()->glFontEnumTitle,
CTX::instance()->glFontSizeTitle, 1);
}
else{
glRasterPos2d(xmin, ymin - 2 * font_h);
ctx->drawString(label, CTX::instance()->glFontTitle,
CTX::instance()->glFontEnumTitle,
CTX::instance()->glFontSizeTitle, 0);
}
}
PView *GMSH_MathEvalPlugin::execute(PView *view)
{
int timeStep = (int)MathEvalOptions_Number[0].def;
int iView = (int)MathEvalOptions_Number[1].def;
int otherTimeStep = (int)MathEvalOptions_Number[2].def;
int iOtherView = (int)MathEvalOptions_Number[3].def;
int forceInterpolation = (int)MathEvalOptions_Number[4].def;
int physicalRegion = (int)MathEvalOptions_Number[5].def;
std::vector<std::string> expr(9);
for(int i = 0; i < 9; i++) expr[i] = MathEvalOptions_String[i].def;
PView *v1 = getView(iView, view);
if(!v1) return view;
PViewData *data1 = getPossiblyAdaptiveData(v1);
if(data1->hasMultipleMeshes()){
Msg::Error("MathEval plugin cannot be applied to multi-mesh views");
return view;
}
PView *otherView = v1;
if(iOtherView >= 0){
otherView = getView(iOtherView, view);
if(!otherView){
Msg::Error("MathEval plugin could not find other view %i", iOtherView);
return view;
}
}
PViewData *otherData = getPossiblyAdaptiveData(otherView);
if(otherData->hasMultipleMeshes()){
Msg::Error("MathEval plugin cannot be applied to multi-mesh views");
return view;
}
if(otherTimeStep < 0 && otherData->getNumTimeSteps() != data1->getNumTimeSteps()){
Msg::Error("Number of time steps don't match: using step 0");
otherTimeStep = 0;
}
else if(otherTimeStep > otherData->getNumTimeSteps() - 1){
Msg::Error("Invalid time step (%d) in View[%d]: using step 0 instead",
otherTimeStep, otherView->getIndex());
otherTimeStep = 0;
}
int numComp2;
if(expr[3].size() || expr[4].size() || expr[5].size() ||
expr[6].size() || expr[7].size() || expr[8].size()){
numComp2 = 9;
for(int i = 0; i < 9; i++)
if(expr[i].empty()) expr[i] = "0";
}
else if(expr[1].size() || expr[2].size()){
numComp2 = 3;
for(int i = 0; i < 3; i++)
if(expr[i].empty()) expr[i] = "0";
}
else{
numComp2 = 1;
}
expr.resize(numComp2);
const char *names[] =
{ "x", "y", "z", "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", "v8",
"w0", "w1", "w2", "w3", "w4", "w5", "w6", "w7", "w8" };
unsigned int numVariables = sizeof(names) / sizeof(names[0]);
std::vector<std::string> variables(numVariables);
for(unsigned int i = 0; i < numVariables; i++) variables[i] = names[i];
mathEvaluator f(expr, variables);
if(expr.empty()) return view;
std::vector<double> values(numVariables), res(numComp2);
OctreePost *octree = 0;
if(forceInterpolation ||
(data1->getNumEntities() != otherData->getNumEntities()) ||
(data1->getNumElements() != otherData->getNumElements())){
Msg::Info("Other view based on different grid: interpolating...");
octree = new OctreePost(otherView);
}
PView *v2 = new PView();
PViewDataList *data2 = getDataList(v2);
if(timeStep < 0){
timeStep = - data1->getNumTimeSteps();
}
else if(timeStep > data1->getNumTimeSteps() - 1){
Msg::Error("Invalid time step (%d) in View[%d]: using all steps instead",
timeStep, v1->getIndex());
timeStep = - data1->getNumTimeSteps();
}
int firstNonEmptyStep = data1->getFirstNonEmptyTimeStep();
int timeBeg = (timeStep < 0) ? firstNonEmptyStep : timeStep;
int timeEnd = (timeStep < 0) ? -timeStep : timeStep + 1;
for(int ent = 0; ent < data1->getNumEntities(timeBeg); ent++){
bool ok = (physicalRegion <= 0);
if(physicalRegion > 0){
GEntity *ge = data1->getEntity(timeBeg, ent);
if(ge){
std::vector<int>::iterator it = std::find
(ge->physicals.begin(), ge->physicals.end(), physicalRegion);
ok = (it != ge->physicals.end());
}
}
if(!ok) continue;
for(int ele = 0; ele < data1->getNumElements(timeBeg, ent); ele++){
if(data1->skipElement(timeBeg, ent, ele)) continue;
int numNodes = data1->getNumNodes(timeBeg, ent, ele);
int type = data1->getType(timeBeg, ent, ele);
int numComp = data1->getNumComponents(timeBeg, ent, ele);
int otherNumComp = (!otherData || octree) ? 9 :
otherData->getNumComponents(timeBeg, ent, ele);
std::vector<double> *out = data2->incrementList(numComp2, type, numNodes);
std::vector<double> v(std::max(9, numComp), 0.);
std::vector<double> w(std::max(9, otherNumComp), 0.);
std::vector<double> x(numNodes), y(numNodes), z(numNodes);
for(int nod = 0; nod < numNodes; nod++)
data1->getNode(timeBeg, ent, ele, nod, x[nod], y[nod], z[nod]);
for(int nod = 0; nod < numNodes; nod++) out->push_back(x[nod]);
for(int nod = 0; nod < numNodes; nod++) out->push_back(y[nod]);
for(int nod = 0; nod < numNodes; nod++) out->push_back(z[nod]);
for(int step = timeBeg; step < timeEnd; step++){
if(!data1->hasTimeStep(step)) continue;
int step2 = (otherTimeStep < 0) ? step : otherTimeStep;
for(int nod = 0; nod < numNodes; nod++){
for(int comp = 0; comp < numComp; comp++)
data1->getValue(step, ent, ele, nod, comp, v[comp]);
if(otherData){
if(octree){
int qn = forceInterpolation ? numNodes : 0;
if(!octree->searchScalar(x[nod], y[nod], z[nod], &w[0], step2,
0, qn, &x[0], &y[0], &z[0]))
if(!octree->searchVector(x[nod], y[nod], z[nod], &w[0], step2,
0, qn, &x[0], &y[0], &z[0]))
octree->searchTensor(x[nod], y[nod], z[nod], &w[0], step2,
0, qn, &x[0], &y[0], &z[0]);
}
else
for(int comp = 0; comp < otherNumComp; comp++)
otherData->getValue(step2, ent, ele, nod, comp, w[comp]);
}
values[0] = x[nod]; values[1] = y[nod]; values[2] = z[nod];
for(int i = 0; i < 9; i++) values[3 + i] = v[i];
for(int i = 0; i < 9; i++) values[12 + i] = w[i];
if(f.eval(values, res)){
for(int i = 0; i < numComp2; i++)
out->push_back(res[i]);
}
else{
goto end;
}
}
}
}
}
end:
if(octree) delete octree;
if(timeStep < 0){
for(int i = firstNonEmptyStep; i < data1->getNumTimeSteps(); i++) {
if(!data1->hasTimeStep(i)) continue;
data2->Time.push_back(data1->getTime(i));
}
}
else
data2->Time.push_back(data1->getTime(timeStep));
data2->setName(data1->getName() + "_MathEval");
data2->setFileName(data1->getName() + "_MathEval.pos");
data2->finalize();
return v2;
}
void drawContext::drawScale()
{
glPushMatrix();
glLoadIdentity();
double size = std::max(_right -_left, _top - _bottom);
double width = size / 3.5;
double height = size / 10.;
double dh = height / 5;
// Draw the scale bar
int nPview = 0;
for(int i=0; i<PView::list.size();i++){
PView *p = PView::list[i];
PViewOptions *opt = p->getOptions();
if(!opt->visible) continue;
PViewData *data = p->getData();
double box = width / (opt->nbIso ? opt->nbIso : 1);
double xmin = _left + (_right - _left - width)/2.;
double ymin = _bottom + 0.7 * height + height * nPview;
std::vector<GLfloat> vertex(opt->nbIso*3*4);
std::vector<GLubyte> color(opt->nbIso*4*4);
for(int i = 0; i < opt->nbIso; i++){
if(opt->intervalsType == PViewOptions::Discrete ||
opt->intervalsType == PViewOptions::Numeric){
unsigned int col = opt->getColor(i, opt->nbIso);
color[i*4*4+0] = color[i*4*4+4] = color[i*4*4+8] = color[i*4*4+12] =
(GLubyte)CTX::instance()->unpackRed(col);
color[i*4*4+1] = color[i*4*4+5] = color[i*4*4+9] = color[i*4*4+13] =
(GLubyte)CTX::instance()->unpackGreen(col);
color[i*4*4+2] = color[i*4*4+6] = color[i*4*4+10] = color[i*4*4+14] =
(GLubyte)CTX::instance()->unpackBlue(col);
color[i*4*4+3] = color[i*4*4+7] = color[i*4*4+11] = color[i*4*4+15] =
(GLubyte)CTX::instance()->unpackAlpha(col);
vertex[i*3*4+0] = xmin + i * box;
vertex[i*3*4+1] = ymin;
vertex[i*3*4+2] = 0.;
vertex[i*3*4+3] = xmin + i * box;
vertex[i*3*4+4] = ymin + dh;
vertex[i*3*4+5] = 0.;
vertex[i*3*4+6] = xmin + (i + 1) * box;
vertex[i*3*4+7] = ymin;
vertex[i*3*4+8] = 0.;
vertex[i*3*4+9] = xmin + (i + 1) * box;
vertex[i*3*4+10] = ymin + dh;
vertex[i*3*4+11] = 0.;
}
else if(opt->intervalsType == PViewOptions::Continuous){
double dv = (opt->tmpMax - opt->tmpMin) / (opt->nbIso ? opt->nbIso : 1);
double v1 = opt->tmpMin + i * dv;
unsigned int col1 = opt->getColor(v1, opt->tmpMin, opt->tmpMax, true);
color[i*4*4+0] = color[i*4*4+4] = (GLubyte)CTX::instance()->unpackRed(col1);
color[i*4*4+1] = color[i*4*4+5] = (GLubyte)CTX::instance()->unpackGreen(col1);
color[i*4*4+2] = color[i*4*4+6] = (GLubyte)CTX::instance()->unpackBlue(col1);
color[i*4*4+3] = color[i*4*4+7] = (GLubyte)CTX::instance()->unpackAlpha(col1);
vertex[i*3*4+0] = xmin + i * box;
vertex[i*3*4+1] = ymin;
vertex[i*3*4+2] = 0.;
vertex[i*3*4+3] = xmin + i * box;
vertex[i*3*4+4] = ymin + dh;
vertex[i*3*4+5] = 0.;
double v2 = opt->tmpMin + (i + 1) * dv;
unsigned int col2 = opt->getColor(v2, opt->tmpMin, opt->tmpMax, true);
color[i*4*4+8] = color[i*4*4+12] = (GLubyte)CTX::instance()->unpackRed(col2);
color[i*4*4+9] = color[i*4*4+13] = (GLubyte)CTX::instance()->unpackGreen(col2);
color[i*4*4+10] = color[i*4*4+14] = (GLubyte)CTX::instance()->unpackBlue(col2);
color[i*4*4+11] = color[i*4*4+15] = (GLubyte)CTX::instance()->unpackAlpha(col2);
vertex[i*3*4+6] = xmin + (i + 1) * box;
vertex[i*3*4+7] = ymin;
vertex[i*3*4+8] = 0.;
vertex[i*3*4+9] = xmin + (i + 1) * box;
vertex[i*3*4+10] = ymin + dh;
vertex[i*3*4+11] = 0.;
}
else{
unsigned int col = opt->getColor(i, opt->nbIso);
color[i*4*4+0] = color[i*4*4+4] = color[i*4*4+8] = color[i*4*4+12] =
(GLubyte)CTX::instance()->unpackRed(col);
color[i*4*4+1] = color[i*4*4+5] = color[i*4*4+9] = color[i*4*4+13] =
(GLubyte)CTX::instance()->unpackGreen(col);
color[i*4*4+2] = color[i*4*4+6] = color[i*4*4+10] = color[i*4*4+14] =
(GLubyte)CTX::instance()->unpackBlue(col);
color[i*4*4+3] = color[i*4*4+7] = color[i*4*4+11] = color[i*4*4+15] =
(GLubyte)CTX::instance()->unpackAlpha(col);
vertex[i*3*4+0] = xmin + i * box;
vertex[i*3*4+1] = ymin;
vertex[i*3*4+2] = 0.;
vertex[i*3*4+3] = xmin + i * box;
vertex[i*3*4+4] = ymin + dh;
vertex[i*3*4+5] = 0.;
vertex[i*3*4+6] = xmin + (i + 1) * box;
vertex[i*3*4+7] = ymin;
vertex[i*3*4+8] = 0.;
vertex[i*3*4+9] = xmin + (i + 1) * box;
vertex[i*3*4+10] = ymin + dh;
vertex[i*3*4+11] = 0.;
}
}
glVertexPointer(3, GL_FLOAT, 0, &vertex[0]);
glEnableClientState(GL_VERTEX_ARRAY);
glColorPointer(4, GL_UNSIGNED_BYTE, 0, &color[0]);
glEnableClientState(GL_COLOR_ARRAY);
if(opt->intervalsType == PViewOptions::Discrete ||
opt->intervalsType == PViewOptions::Numeric ||
opt->intervalsType == PViewOptions::Continuous)
glDrawArrays(GL_TRIANGLE_STRIP, 0, opt->nbIso*4);
else
glDrawArrays(GL_LINES, 0, opt->nbIso*4);
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
char label[1024];
int nt = data->getNumTimeSteps();
if((opt->showTime == 1 && nt > 1) || opt->showTime == 2){
char tmp[256];
sprintf(tmp, opt->format.c_str(), data->getTime(opt->timeStep));
sprintf(label, "%s (%s)", data->getName().c_str(), tmp);
}
else if((opt->showTime == 3 && nt > 1) || opt->showTime == 4){
sprintf(label, "%s (%d/%d)", data->getName().c_str(), opt->timeStep,
data->getNumTimeSteps() - 1);
}
else{
sprintf(label, "%s", data->getName().c_str());
}
drawString lbl(label, 20 * _fontFactor);
lbl.draw(xmin + width / 2, ymin + 2.8 * dh, 0.,
_width/(_right-_left), _height/(_top-_bottom));
drawString val(data->getName().c_str(), 15 * _fontFactor);
for(int i = 0; i < 3; i++) {
double v = opt->getScaleValue(i, 3, opt->tmpMin, opt->tmpMax);
sprintf(label, opt->format.c_str(), v);
val.setText(label);
val.draw(xmin + i * width/ 2, ymin + 1.5 * dh, 0.,
_width/(_right-_left), _height/(_top-_bottom));
}
nPview++;
}
glPopMatrix();
}
PView *GMSH_Scal2VecPlugin::execute(PView *v)
{
int iViewX = (int)Scal2VecOptions_Number[0].def;
int iViewY = (int)Scal2VecOptions_Number[1].def;
int iViewZ = (int)Scal2VecOptions_Number[2].def;
std::string nameNewView = Scal2VecOptions_String[0].def;
PView *vRef = 0, *vX = 0, *vY = 0, *vZ = 0;
PViewData *dataRef = 0, *dataX = 0, *dataY = 0, *dataZ = 0;
// Load data
if(iViewX >= 0){
vX = getView(iViewX, v);
if(!vX){
Msg::Error("Scal2Vec plugin could not find View X: %i", iViewX);
return v;
}
dataX = vX->getData();
if(!vRef){
vRef = vX;
dataRef = dataX;
}
}
if(iViewY >= 0){
vY = getView(iViewY, v);
if(!vY){
Msg::Error("Scal2Vec plugin could not find View Y: %i", iViewY);
return v;
}
dataY = vY->getData();
if(!vRef){
vRef = vY;
dataRef = dataY;
}
}
if(iViewZ >= 0){
vZ = getView(iViewZ, v);
if(!vZ){
Msg::Error("Scal2Vec plugin could not find View Z: %i", iViewZ);
return v;
}
dataZ = vZ->getData();
if(!vRef){
vRef = vZ;
dataRef = dataZ;
}
}
if(!vRef){
Msg::Error("Scal2Vec plugin could not find any view.", iViewZ);
return v;
}
// Initialize the new view
PView *vNew = new PView();
PViewDataList *dataNew = getDataList(vNew);
for(int ent = 0; ent < dataRef->getNumEntities(0); ent++){
for(int ele = 0; ele < dataRef->getNumElements(0, ent); ele++){
if(dataRef->skipElement(0, ent, ele)) continue;
int numComp = 3; // The 3 components of the new view: x,y,z
int type = dataRef->getType(0, ent, ele);
int numNodes = dataRef->getNumNodes(0, ent, ele);
std::vector<double> *out = dataNew->incrementList(numComp, type, numNodes); // Pointer in data of the new view
if(!out) continue;
double x[8], y[8], z[8], valX, valY, valZ;
for(int nod = 0; nod < numNodes; nod++)
dataRef->getNode(0, ent, ele, nod, x[nod], y[nod], z[nod]);
int dim = dataRef->getDimension(0, ent, ele);
elementFactory factory;
element *element = factory.create(numNodes, dim, x, y, z);
if(!element) continue;
for(int nod = 0; nod < numNodes; nod++) out->push_back(x[nod]); // Save coordinates (x,y,z)
for(int nod = 0; nod < numNodes; nod++) out->push_back(y[nod]);
for(int nod = 0; nod < numNodes; nod++) out->push_back(z[nod]);
for(int step = 0; step < dataRef->getNumTimeSteps(); step++){
for(int nod = 0; nod < numNodes; nod++){
if(vX) dataX->getValue(step, ent, ele, nod, 0, valX); else valX = 0;
if(vY) dataY->getValue(step, ent, ele, nod, 0, valY); else valY = 0;
if(vZ) dataZ->getValue(step, ent, ele, nod, 0, valZ); else valZ = 0;
out->push_back(valX); // Save values (fx,fy,fz)
out->push_back(valY);
out->push_back(valZ);
}
}
delete element;
}
}
for(int step = 0; step < dataRef->getNumTimeSteps(); step++){
if(dataRef->hasTimeStep(step)){
double time = dataRef->getTime(step);
dataNew->Time.push_back(time);
}
}
dataNew->setName(nameNewView);
dataNew->setFileName(nameNewView + ".pos");
dataNew->finalize();
return vNew;
}
void drawContext::drawScales()
{
std::vector<PView*> scales;
for(unsigned int i = 0; i < PView::list.size(); i++){
PViewData *data = PView::list[i]->getData();
PViewOptions *opt = PView::list[i]->getOptions();
if(!data->getDirty() && opt->visible && opt->showScale &&
opt->type == PViewOptions::Plot3D && data->getNumElements() &&
isVisible(PView::list[i]))
scales.push_back(PView::list[i]);
}
if(scales.empty()) return;
drawContext::global()->setFont(CTX::instance()->glFontEnum,
CTX::instance()->glFontSize);
char label[1024];
double maxw = 0.;
for(unsigned int i = 0; i < scales.size(); i++) {
PViewOptions *opt = scales[i]->getOptions();
sprintf(label, opt->format.c_str(), -M_PI * 1.e-4);
maxw = std::max(maxw, drawContext::global()->getStringWidth(label));
}
const double tic = 10., bar_size = 16.;
double width = 0., width_prev = 0., width_total = 0.;
for(unsigned int i = 0; i < scales.size(); i++) {
PView *p = scales[i];
PViewData *data = p->getData();
PViewOptions *opt = p->getOptions();
if(!opt->autoPosition) {
double w = opt->size[0], h = opt->size[1];
double x = opt->position[0], y = opt->position[1] - h;
int c = fix2dCoordinates(&x, &y);
if(c & 1) x -= w / 2.;
if(c & 2) y += h / 2.;
drawScale(this, p, x, y, w, h, tic, CTX::instance()->post.horizontalScales);
}
else if(CTX::instance()->post.horizontalScales){
double ysep = 20.;
double xc = (viewport[2] - viewport[0]) / 2.;
if(scales.size() == 1){
double w = (viewport[2] - viewport[0]) / 2., h = bar_size;
double x = xc - w / 2., y = viewport[1] + ysep;
drawScale(this, p, x, y, w, h, tic, 1);
}
else{
double xsep = maxw / 4. + (viewport[2] - viewport[0]) / 10.;
double w = (viewport[2] - viewport[0] - 4 * xsep) / 2.;
if(w < 20.) w = 20.;
double h = bar_size;
double x = xc - (i % 2 ? -xsep / 1.5 : w + xsep / 1.5);
double y = viewport[1] + ysep +
(i / 2) * (bar_size + tic +
2 * drawContext::global()->getStringHeight() + ysep);
drawScale(this, p, x, y, w, h, tic, 1);
}
}
else{
double xsep = 20.;
double dy = 2. * drawContext::global()->getStringHeight();
if(scales.size() == 1){
double ysep = (viewport[3] - viewport[1]) / 6.;
double w = bar_size, h = viewport[3] - viewport[1] - 2 * ysep - dy;
double x = viewport[0] + xsep, y = viewport[1] + ysep + dy;
drawScale(this, p, x, y, w, h, tic, 0);
}
else{
double ysep = (viewport[3] - viewport[1]) / 15.;
double w = bar_size;
double h = (viewport[3] - viewport[1] - 3 * ysep - 2.5 * dy) / 2.;
double x = viewport[0] + xsep + width_total + (i / 2) * xsep;
double y = viewport[1] + ysep + dy + (1 - i % 2) * (h + 1.5 * dy + ysep);
drawScale(this, p, x, y, w, h, tic, 0);
}
// compute width
width_prev = width;
sprintf(label, opt->format.c_str(), -M_PI * 1.e-4);
width = bar_size + tic + drawContext::global()->getStringWidth(label);
if(opt->showTime){
char tmp[256];
sprintf(tmp, opt->format.c_str(), data->getTime(opt->timeStep));
sprintf(label, "%s (%s)", data->getName().c_str(), tmp);
}
else
sprintf(label, "%s", data->getName().c_str());
width = std::max(width, drawContext::global()->getStringWidth(label));
if(i % 2) width_total += std::max(bar_size + width, bar_size + width_prev);
}
}
}
void PView::combine(bool time, int how, bool remove)
{
// time == true: combine the timesteps (oherwise combine the elements)
// how == 0: try to combine all visible views
// 1: try to combine all views
// 2: try to combine all views having identical names
std::vector<nameData> nds;
for(unsigned int i = 0; i < list.size(); i++) {
PView *p = list[i];
PViewData *data = p->getData();
if(how || p->getOptions()->visible) {
nameData nd;
// this will lead to weird results if there are views named
// "__all__" or "__vis__" :-)
if(how == 2)
nd.name = data->getName();
else if(how == 1)
nd.name = "__all__";
else
nd.name = "__vis__";
unsigned int j = 0;
while(j < nds.size()){
if(nds[j].name == nd.name){
nds[j].data.push_back(data);
nds[j].indices.push_back(i);
break;
}
j++;
}
if(j == nds.size()){
nd.data.push_back(data);
nd.indices.push_back(i);
nds.push_back(nd);
}
}
}
std::set<PView*> rm;
for(unsigned int i = 0; i < nds.size(); i++){
if(nds[i].data.size() > 1){ // there's potentially something to combine
// sanity checks:
bool allListBased = true, allModelBased = true;
for(unsigned int j = 0; j < nds[i].data.size(); j++){
PViewDataList *d1 = dynamic_cast<PViewDataList*>(nds[i].data[j]);
if(!d1) allListBased = false;
PViewDataGModel *d2 = dynamic_cast<PViewDataGModel*>(nds[i].data[j]);
if(!d2) allModelBased = false;
}
PViewData *data = 0;
if(allListBased){
data = new PViewDataList();
}
else if(allModelBased){
PViewDataGModel *d2 = dynamic_cast<PViewDataGModel*>(nds[i].data[0]);
data = new PViewDataGModel(d2->getType());
}
else{
Msg::Error("Cannot combine hybrid list/mesh-based datasets");
continue;
}
PView *p = new PView(data);
bool res = time ? data->combineTime(nds[i]) : data->combineSpace(nds[i]);
if(res){
for(unsigned int j = 0; j < nds[i].indices.size(); j++)
rm.insert(list[nds[i].indices[j]]);
PViewOptions *opt = p->getOptions();
if(opt->adaptVisualizationGrid){
// the (empty) adaptive data created in PView() must be
// recreated, since we added some data
data->destroyAdaptiveData();
data->initAdaptiveData
(opt->timeStep, opt->maxRecursionLevel, opt->targetError);
}
}
else
delete p;
}
}
if(remove)
for(std::set<PView*>::iterator it = rm.begin(); it != rm.end(); it++)
delete *it;
}
PView *GMSH_Scal2VecPlugin::execute(PView *v)
{
// Load options
int iView[3];
for (int comp=0; comp<3; comp++)
iView[comp] = (int)Scal2VecOptions_Number[comp].def;
// Load data
PView *vRef=0, *vComp[3];
for (int comp=0; comp<3; comp++) {
if (iView[comp]<0) vComp[comp] = 0;
else {
vComp[comp] = getView(iView[comp], v);
if (!vComp[comp]) {
Msg::Error("Scal2Vec plugin could not find View '%i'", iView[comp]);
return v;
}
if (!vRef) vRef = vComp[comp];
}
}
if (!vRef) {
Msg::Error("Scal2Vec plugin could not find any view.");
return v;
}
PViewData *dataRef = vRef->getData();
// Initialize the new view
PView *vNew = new PView();
PViewDataList *dataNew = getDataList(vNew);
int step0 = dataRef->getFirstNonEmptyTimeStep();
for (int ent=0; ent < dataRef->getNumEntities(step0); ent++) {
for (int ele=0; ele < dataRef->getNumElements(step0, ent); ele++) {
if (dataRef->skipElement(step0, ent, ele)) continue;
int type = dataRef->getType(step0, ent, ele);
int numNodes = dataRef->getNumNodes(step0, ent, ele);
std::vector<double> *out = dataNew->incrementList(3, type, numNodes); // Pointer in data of the new view
if (!out) continue;
double x[8], y[8], z[8];
for (int nod=0; nod<numNodes; nod++)
dataRef->getNode(step0, ent, ele, nod, x[nod], y[nod], z[nod]);
int dim = dataRef->getDimension(step0, ent, ele);
elementFactory factory;
element *element = factory.create(numNodes, dim, x, y, z);
if (!element) continue;
for (int nod=0; nod<numNodes; nod++) out->push_back(x[nod]); // Save coordinates (x,y,z)
for (int nod=0; nod<numNodes; nod++) out->push_back(y[nod]);
for (int nod=0; nod<numNodes; nod++) out->push_back(z[nod]);
for (int step=step0; step < dataRef->getNumTimeSteps(); step++) {
if (!dataRef->hasTimeStep(step)) continue;
for (int nod=0; nod<numNodes; nod++) {
for (int comp=0; comp<3; comp++) {
double val=0.;
if(vComp[comp]) vComp[comp]->getData()->getValue(step, ent, ele, nod, 0, val);
out->push_back(val); // Save value
}
}
}
delete element;
}
}
for (int step=step0; step < dataRef->getNumTimeSteps(); step++) {
if (!dataRef->hasTimeStep(step)) continue;
dataNew->Time.push_back(dataRef->getTime(step));
}
std::string nameNewView = Scal2VecOptions_String[0].def;
dataNew->setName(nameNewView);
dataNew->setFileName(nameNewView + ".pos");
dataNew->finalize();
return vNew;
}
PView *GMSH_LevelsetPlugin::execute(PView *v)
{
// for adapted views we can only run the plugin on one step at a time
if(v->getData()->getAdaptiveData()){
PViewOptions *opt = v->getOptions();
v->getData()->getAdaptiveData()->changeResolution
(opt->timeStep, _recurLevel, _targetError, this);
v->setChanged(true);
}
PViewData *vdata = getPossiblyAdaptiveData(v), *wdata;
if(_valueView < 0) {
wdata = vdata;
}
else if(_valueView > (int)PView::list.size() - 1){
Msg::Error("View[%d] does not exist: reverting to View[%d]",
_valueView, v->getIndex());
wdata = vdata;
}
else{
wdata = getPossiblyAdaptiveData(PView::list[_valueView]);
}
// sanity checks
if(vdata->getNumEntities() != wdata->getNumEntities() ||
vdata->getNumElements() != wdata->getNumElements()){
Msg::Error("Incompatible views");
return v;
}
if(_valueTimeStep >= wdata->getNumTimeSteps()) {
Msg::Error("Wrong time step %d in view", _valueTimeStep);
return v;
}
// Force creation of one view per time step if we have multi meshes
if(vdata->hasMultipleMeshes()) _valueIndependent = 0;
double x[8], y[8], z[8], levels[8];
double scalarValues[8] = {0., 0., 0., 0., 0., 0., 0., 0.};
if(_valueIndependent) {
// create a single output view containing the (possibly
// multi-step) levelset
int firstNonEmptyStep = vdata->getFirstNonEmptyTimeStep();
PViewDataList *out = getDataList(new PView());
for(int ent = 0; ent < vdata->getNumEntities(firstNonEmptyStep); ent++){
for(int ele = 0; ele < vdata->getNumElements(firstNonEmptyStep, ent); ele++){
if(vdata->skipElement(firstNonEmptyStep, ent, ele)) continue;
for(int nod = 0; nod < vdata->getNumNodes(firstNonEmptyStep, ent, ele); nod++){
vdata->getNode(firstNonEmptyStep, ent, ele, nod, x[nod], y[nod], z[nod]);
levels[nod] = levelset(x[nod], y[nod], z[nod], 0.);
}
_cutAndAddElements(vdata, wdata, ent, ele, -1, _valueTimeStep, x, y, z,
levels, scalarValues, out);
}
}
out->setName(vdata->getName() + "_Levelset");
out->setFileName(vdata->getFileName() + "_Levelset.pos");
out->finalize();
}
else{
// create one view per timestep
for(int step = 0; step < vdata->getNumTimeSteps(); step++){
if(!vdata->hasTimeStep(step)) continue;
PViewDataList *out = getDataList(new PView());
for(int ent = 0; ent < vdata->getNumEntities(step); ent++){
for(int ele = 0; ele < vdata->getNumElements(step, ent); ele++){
if(vdata->skipElement(step, ent, ele)) continue;
for(int nod = 0; nod < vdata->getNumNodes(step, ent, ele); nod++){
vdata->getNode(step, ent, ele, nod, x[nod], y[nod], z[nod]);
vdata->getScalarValue(step, ent, ele, nod, scalarValues[nod]);
levels[nod] = levelset(x[nod], y[nod], z[nod], scalarValues[nod]);
}
int wstep = (_valueTimeStep < 0) ? step : _valueTimeStep;
_cutAndAddElements(vdata, wdata, ent, ele, step, wstep, x, y, z,
levels, scalarValues, out);
}
}
char tmp[246];
sprintf(tmp, "_Levelset_%d", step);
out->setName(vdata->getName() + tmp);
out->setFileName(vdata->getFileName() + tmp + ".pos");
out->finalize();
}
}
return 0;
}
