How to fix the colorbar range?

[e-aranda]

I would like to represent different results with the same colorbar range. I mean,
I have two sets of data, the first one with values between 0 and 1, the second one between 0 and 0.7. Using the same palette, the color of a 0.5 value in the first one data set is different from the color of the second one for the same value because colorbar is adapted to the range values. Is it possible to represent the second set of data with a colorbar going from 0 to 1?

[jakubcerveny]

I think it's the F7 key that you can set the min/max of the colorbar with. If you press H, a help on most of the keys is displayed in the terminal.

[e-aranda]

Ok, thank you. I did not know it was possible to do it. I also have found how to set using key parameters. In case anyone is interested:

sout << "valuerange min max\n";

By the way, is there a tutorial where all this option are explained?

[tzanio]

The README file is probably the best "tutorial" for the available keystrokes.

All GLVis "commands" like valuerange above a listed in this portion of the code:

glvis/glvis.cpp

Lines 763 to 1020 in e46168b

	else if (word == "screenshot")
	{
	scr >> ws >> word;
	cout << "Script: screenshot: " << flush;
	if (Screenshot(word.c_str(), true))
	{
	cout << "Screenshot(" << word << ") failed." << endl;
	done_one_command = 1;
	continue;
	}
	cout << "-> " << word << endl;
	if (scr_min_val > vs->GetMinV())
	{
	scr_min_val = vs->GetMinV();
	}
	if (scr_max_val < vs->GetMaxV())
	{
	scr_max_val = vs->GetMaxV();
	}
	}
	else if (word == "viewcenter")
	{
	scr >> vs->ViewCenterX >> vs->ViewCenterY;
	cout << "Script: viewcenter: "
	<< vs->ViewCenterX << ' ' << vs->ViewCenterY << endl;
	MyExpose();
	}
	else if (word == "perspective")
	{
	scr >> ws >> word;
	cout << "Script: perspective: " << word;
	if (word == "off")
	{
	vs->OrthogonalProjection = 1;
	}
	else if (word == "on")
	{
	vs->OrthogonalProjection = 0;
	}
	else
	{
	cout << '?';
	}
	cout << endl;
	MyExpose();
	}
	else if (word == "light")
	{
	scr >> ws >> word;
	cout << "Script: light: " << word;
	if (word == "off")
	{
	vs->light = 0;
	}
	else if (word == "on")
	{
	vs->light = 1;
	}
	else
	{
	cout << '?';
	}
	cout << endl;
	MyExpose();
	}
	else if (word == "view")
	{
	double theta, phi;
	scr >> theta >> phi;
	cout << "Script: view: " << theta << ' ' << phi << endl;
	vs->SetView(theta, phi);
	MyExpose();
	}
	else if (word == "zoom")
	{
	double factor;
	scr >> factor;
	cout << "Script: zoom: " << factor << endl;
	vs->Zoom(factor);
	MyExpose();
	}
	else if (word == "shading")
	{
	scr >> ws >> word;
	cout << "Script: shading: " << flush;
	int s = -1;
	if (word == "flat")
	{
	s = 0;
	}
	else if (word == "smooth")
	{
	s = 1;
	}
	else if (word == "cool")
	{
	s = 2;
	}
	if (s != -1)
	{
	vs->SetShading(s, false);
	cout << word << endl;
	MyExpose();
	}
	else
	{
	cout << word << " ?" << endl;
	}
	}
	else if (word == "subdivisions")
	{
	int t, b;
	scr >> t >> b;
	cout << "Script: subdivisions: " << flush;
	vs->SetRefineFactors(t, b);
	cout << t << ' ' << b << endl;
	MyExpose();
	}
	else if (word == "valuerange")
	{
	double min, max;
	scr >> min >> max;
	cout << "Script: valuerange: " << flush;
	vs->SetValueRange(min, max);
	cout << min << ' ' << max << endl;
	MyExpose();
	}
	else if (word == "autoscale")
	{
	scr >> ws >> word;
	cout << "Script: autoscale: " << word;
	if (word == "off")
	{
	vs->SetAutoscale(0);
	}
	else if (word == "on")
	{
	vs->SetAutoscale(1);
	}
	else if (word == "value")
	{
	vs->SetAutoscale(2);
	}
	else if (word == "mesh")
	{
	vs->SetAutoscale(3);
	}
	else
	{
	cout << '?';
	}
	cout << endl;
	}
	else if (word == "window")
	{
	scr >> window_x >> window_y >> window_w >> window_h;
	cout << "Script: window: " << window_x << ' ' << window_y
	<< ' ' << window_w << ' ' << window_h << endl;
	MoveResizeWindow(window_x, window_y, window_w, window_h);
	MyExpose();
	}
	else if (word == "keys")
	{
	scr >> keys;
	cout << "Script: keys: '" << keys << "'" << endl;
	// SendKeySequence(keys.c_str());
	CallKeySequence(keys.c_str());
	MyExpose();
	}
	else if (word == "palette")
	{
	int pal;
	scr >> pal;
	cout << "Script: palette: " << pal << endl;
	Set_Palette(pal-1);
	if (!GetUseTexture())
	{
	vs->EventUpdateColors();
	}
	MyExpose();
	}
	else if (word == "toggle_attributes")
	{
	Array<int> attr_list;
	cout << "Script: toggle_attributes:";
	for (scr >> ws; scr.peek() != ';'; scr >> ws)
	{
	attr_list.Append(0);
	scr >> attr_list.Last();
	if (attr_list.Size() <= 256)
	{
	cout << ' ' << attr_list.Last();
	}
	else if (attr_list.Size() == 257)
	{
	cout << " ... " << flush;
	}
	}
	scr.get(); // read the end symbol: ';'
	cout << endl;
	vs->ToggleAttributes(attr_list);
	MyExpose();
	}
	else if (word == "rotmat")
	{
	cout << "Script: rotmat:";
	for (int i = 0; i < 16; i++)
	{
	scr >> vs->rotmat[i];
	cout << ' ' << vs->rotmat[i];
	}
	cout << endl;
	MyExpose();
	}
	else if (word == "camera")
	{
	double cam[9];
	cout << "Script: camera:";
	for (int i = 0; i < 9; i++)
	{
	scr >> cam[i];
	cout << ' ' << cam[i];
	}
	cout << endl;
	vs->cam.Set(cam);
	MyExpose();
	}
	else if (word == "scale")
	{
	double scale;
	cout << "Script: scale:";
	scr >> scale;
	cout << ' ' << scale;
	cout << endl;
	vs->Scale(scale);
	MyExpose();
	}
	else if (word == "translate")
	{
	double x, y, z;
	cout << "Script: translate:";
	scr >> x >> y >> z;
	cout << ' ' << x << ' ' << y << ' ' << z;
	cout << endl;
	vs->Translate(x, y, z);
	MyExpose();
	}
	else if (word == "plot_caption")
	{
	char delim;
	scr >> ws >> delim;
	getline(scr, plot_caption, delim);
	vs->UpdateCaption(); // turn on or off the caption
	MyExpose();
	}

We plan to work on better documentation in the future.

[v-dobrev]

Just to clarify: there are two different (though intentionally very similar) sets of GLVis commands: one for commands in GLVis scripts (executed from the command line with the -run/--run-script option) and commands sent to GLVis through socket connections. What @tzanio linked above are the script commands. The socket commands are in the following big if statement:

glvis/lib/threads.cpp

Lines 810 to 1245 in f85cf7c

	if (_this->ident == "mesh" || _this->ident == "solution" ||
	_this->ident == "parallel")
	{
	bool fix_elem_orient = glvis_command->FixElementOrientations();
	if (_this->ident == "mesh")
	{
	_this->new_m = new Mesh(*_this->is[0], 1, 0, fix_elem_orient);
	if (!(*_this->is[0]))
	{
	break;
	}
	_this->new_g = NULL;
	}
	else if (_this->ident == "solution")
	{
	_this->new_m = new Mesh(*_this->is[0], 1, 0, fix_elem_orient);
	if (!(*_this->is[0]))
	{
	break;
	}
	_this->new_g = new GridFunction(_this->new_m, *_this->is[0]);
	if (!(*_this->is[0]))
	{
	break;
	}
	}
	else if (_this->ident == "parallel")
	{
	Array<Mesh *> mesh_array;
	Array<GridFunction *> gf_array;
	int proc, nproc, np = 0;
	bool keep_attr = glvis_command->KeepAttrib();
	do
	{
	istream &isock = *_this->is[np];
	isock >> nproc >> proc >> ws;
	#ifdef GLVIS_DEBUG
	cout << "connection[" << np << "]: parallel " << nproc << ' '
	<< proc << endl;
	#endif
	isock >> _this->ident >> ws; // "solution"
	mesh_array.SetSize(nproc);
	gf_array.SetSize(nproc);
	mesh_array[proc] = new Mesh(isock, 1, 0, fix_elem_orient);
	if (!keep_attr)
	{
	// set element and boundary attributes to proc+1
	for (int i = 0; i < mesh_array[proc]->GetNE(); i++)
	{
	mesh_array[proc]->GetElement(i)->SetAttribute(proc+1);
	}
	for (int i = 0; i < mesh_array[proc]->GetNBE(); i++)
	{
	mesh_array[proc]->GetBdrElement(i)->SetAttribute(proc+1);
	}
	}
	gf_array[proc] = new GridFunction(mesh_array[proc], isock);
	np++;
	if (np == nproc)
	{
	break;
	}
	*_this->is[np] >> _this->ident >> ws; // "parallel"
	}
	while (1);
	_this->new_m = new Mesh(mesh_array, nproc);
	_this->new_g = new GridFunction(_this->new_m, gf_array, nproc);
	for (int p = 0; p < nproc; p++)
	{
	delete gf_array[nproc-1-p];
	delete mesh_array[nproc-1-p];
	}
	gf_array.DeleteAll();
	mesh_array.DeleteAll();
	}
	// cout << "Stream: new solution" << endl;
	Extrude1DMeshAndSolution(&_this->new_m, &_this->new_g, NULL);
	if (glvis_command->NewMeshAndSolution(_this->new_m, _this->new_g))
	{
	goto comm_terminate;
	}
	_this->new_m = NULL;
	_this->new_g = NULL;
	}
	else if (_this->ident == "screenshot")
	{
	string filename;
	*_this->is[0] >> ws >> filename;
	// all processors sent the screenshot command
	for (int i = 1; i < _this->is.Size(); i++)
	{
	*_this->is[i] >> ws >> _this->ident; // 'screenshot'
	*_this->is[i] >> ws >> _this->ident; // filename
	}
	if (glvis_command->Screenshot(filename.c_str()))
	{
	goto comm_terminate;
	}
	}
	else if (_this->ident == "keys")
	{
	string keys;
	*_this->is[0] >> ws >> keys;
	// all processors sent the command
	for (int i = 1; i < _this->is.Size(); i++)
	{
	*_this->is[i] >> ws >> _this->ident; // 'keys'
	*_this->is[i] >> ws >> _this->ident; // keys
	}
	if (glvis_command->KeyCommands(keys.c_str()))
	{
	goto comm_terminate;
	}
	}
	else if (_this->ident == "window_size")
	{
	int w, h, t;
	*_this->is[0] >> w >> h;
	// all processors sent the command
	for (int i = 1; i < _this->is.Size(); i++)
	{
	*_this->is[i] >> ws >> _this->ident; // 'window_size'
	*_this->is[i] >> t >> t;
	}
	if (glvis_command->WindowSize(w, h))
	{
	goto comm_terminate;
	}
	}
	else if (_this->ident == "window_geometry")
	{
	int x, y, w, h, t;
	*_this->is[0] >> x >> y >> w >> h;
	// all processors sent the command
	for (int i = 1; i < _this->is.Size(); i++)
	{
	*_this->is[i] >> ws >> _this->ident; // 'window_geometry'
	*_this->is[i] >> t >> t >> t >> t;
	}
	if (glvis_command->WindowGeometry(x, y, w, h))
	{
	goto comm_terminate;
	}
	}
	else if (_this->ident == "window_title")
	{
	char c;
	string title;
	*_this->is[0] >> ws >> c; // read the opening char
	// use the opening char as termination as well
	getline(*_this->is[0], title, c);
	// all processors sent the command
	for (int i = 1; i < _this->is.Size(); i++)
	{
	*_this->is[i] >> ws >> _this->ident; // 'window_title'
	*_this->is[i] >> ws >> c;
	getline(*_this->is[i], _this->ident, c);
	}
	if (glvis_command->WindowTitle(title.c_str()))
	{
	goto comm_terminate;
	}
	}
	else if (_this->ident == "plot_caption")
	{
	char c;
	string caption;
	*_this->is[0] >> ws >> c; // read the opening char
	// use the opening char as termination as well
	getline(*_this->is[0], caption, c);
	// all processors sent the command
	for (int i = 1; i < _this->is.Size(); i++)
	{
	*_this->is[i] >> ws >> _this->ident; // 'plot_caption'
	*_this->is[i] >> ws >> c;
	getline(*_this->is[i], _this->ident, c);
	}
	if (glvis_command->PlotCaption(caption.c_str()))
	{
	goto comm_terminate;
	}
	}
	else if (_this->ident == "axis_labels")
	{
	char c;
	string label_x, label_y, label_z;
	*_this->is[0] >> ws >> c; // read the opening char
	// use the opening char as termination as well
	getline(*_this->is[0], label_x, c);
	*_this->is[0] >> ws >> c;
	getline(*_this->is[0], label_y, c);
	*_this->is[0] >> ws >> c;
	getline(*_this->is[0], label_z, c);
	// all processors sent the command
	for (int i = 1; i < _this->is.Size(); i++)
	{
	*_this->is[i] >> ws >> _this->ident; // 'axis_label'
	*_this->is[i] >> ws >> c;
	getline(*_this->is[i], _this->ident, c);
	*_this->is[i] >> ws >> c;
	getline(*_this->is[i], _this->ident, c);
	*_this->is[i] >> ws >> c;
	getline(*_this->is[i], _this->ident, c);
	}
	if (glvis_command->AxisLabels(label_x.c_str(),
	label_y.c_str(),
	label_z.c_str()))
	{
	goto comm_terminate;
	}
	}
	else if (_this->ident == "pause")
	{
	// all processors sent the command
	for (int i = 1; i < _this->is.Size(); i++)
	{
	*_this->is[i] >> ws >> _this->ident; // 'pause'
	}
	if (glvis_command->Pause())
	{
	goto comm_terminate;
	}
	}
	else if (_this->ident == "view")
	{
	double theta, phi, a;
	*_this->is[0] >> theta >> phi;
	// all processors sent the command
	for (int i = 1; i < _this->is.Size(); i++)
	{
	*_this->is[i] >> ws >> _this->ident; // 'view'
	*_this->is[i] >> a >> a;
	}
	if (glvis_command->ViewAngles(theta, phi))
	{
	goto comm_terminate;
	}
	}
	else if (_this->ident == "zoom")
	{
	double factor, a;
	*_this->is[0] >> factor;
	// all processors sent the command
	for (int i = 1; i < _this->is.Size(); i++)
	{
	*_this->is[i] >> ws >> _this->ident; // 'zoom'
	*_this->is[i] >> a;
	}
	if (glvis_command->Zoom(factor))
	{
	goto comm_terminate;
	}
	}
	else if (_this->ident == "subdivisions")
	{
	int tot, bdr, a;
	*_this->is[0] >> tot >> bdr;
	// all processors sent the command
	for (int i = 1; i < _this->is.Size(); i++)
	{
	*_this->is[i] >> ws >> _this->ident; // 'subdivisions'
	*_this->is[i] >> a >> a;
	}
	if (glvis_command->Subdivisions(tot, bdr))
	{
	goto comm_terminate;
	}
	}
	else if (_this->ident == "valuerange")
	{
	double minv, maxv, a;
	*_this->is[0] >> minv >> maxv;
	// all processors sent the command
	for (int i = 1; i < _this->is.Size(); i++)
	{
	*_this->is[i] >> ws >> _this->ident; // 'valuerange'
	*_this->is[i] >> a >> a;
	}
	if (glvis_command->ValueRange(minv, maxv))
	{
	goto comm_terminate;
	}
	}
	else if (_this->ident == "shading")
	{
	string shd;
	*_this->is[0] >> ws >> shd;
	// all processors sent the command
	for (int i = 1; i < _this->is.Size(); i++)
	{
	*_this->is[i] >> ws >> _this->ident; // 'shading'
	*_this->is[i] >> ws >> _this->ident;
	}
	if (glvis_command->SetShading(shd.c_str()))
	{
	goto comm_terminate;
	}
	}
	else if (_this->ident == "viewcenter")
	{
	double x, y, a;
	*_this->is[0] >> x >> y;
	// all processors sent the command
	for (int i = 1; i < _this->is.Size(); i++)
	{
	*_this->is[i] >> ws >> _this->ident; // 'viewcenter'
	*_this->is[i] >> a >> a;
	}
	if (glvis_command->ViewCenter(x, y))
	{
	goto comm_terminate;
	}
	}
	else if (_this->ident == "autoscale")
	{
	string mode;
	*_this->is[0] >> ws >> mode;
	// all processors sent the command
	for (int i = 1; i < _this->is.Size(); i++)
	{
	*_this->is[i] >> ws >> _this->ident; // 'autoscale'
	*_this->is[i] >> ws >> _this->ident;
	}
	if (glvis_command->Autoscale(mode.c_str()))
	{
	goto comm_terminate;
	}
	}
	else if (_this->ident == "palette")
	{
	int pal, a;
	*_this->is[0] >> pal;
	// all processors sent the command
	for (int i = 1; i < _this->is.Size(); i++)
	{
	*_this->is[i] >> ws >> _this->ident; // 'palette'
	*_this->is[i] >> a;
	}
	if (glvis_command->Palette(pal))
	{
	goto comm_terminate;
	}
	}
	else if (_this->ident == "camera")
	{
	double cam[9], a;
	for (int i = 0; i < 9; i++)
	{
	*_this->is[0] >> cam[i];
	}
	// all processors sent the command
	for (int i = 1; i < _this->is.Size(); i++)
	{
	*_this->is[i] >> ws >> _this->ident; // 'camera'
	for (int j = 0; j < 9; j++)
	{
	*_this->is[i] >> a;
	}
	}
	if (glvis_command->Camera(cam))
	{
	goto comm_terminate;
	}
	}
	else if (_this->ident == "autopause")
	{
	string mode;
	*_this->is[0] >> ws >> mode;
	// all processors sent the command
	for (int i = 1; i < _this->is.Size(); i++)
	{
	*_this->is[i] >> ws >> _this->ident; // 'autopause'
	*_this->is[i] >> ws >> _this->ident;
	}
	if (glvis_command->Autopause(mode.c_str()))
	{
	goto comm_terminate;
	}
	}

[v-dobrev]

By the way, regarding GLVis scripts, there is a short description of this capability here: https://glvis.org/options-and-use.

[HennesHajduk]

Using these hints I am able to do one of the following things:

1. Rescale the socketstream with F7 key for each image. Downside: works only manually.
2. Run a glvs-script to adjust the valuerange before taking a snapshot (or doing something similar). Downside: Output to files is required first.

I wonder if there is an easy way to have the valuerange "pre-defined" when an inputstream is sent live to glvis (when a non-steady problem is solved). I tried

sock << "solution\n";
mesh.Print(sock);
gf.Save(sock);
sock << "valuerange 0 1\n";

Apparently, valuerange has to be specified after the GridFunction is saved. So this approach first plots in the custom range and then re-scales it just afterwards, which makes it hard to work with for me.

Any ideas?

[v-dobrev]

@HennesHajduk, there is a command autoscale <mode>, where <mode> can be:

• off - turn off autoscaling for both mesh box and value range
• on (default) - turn on autoscaling for both mesh box and value range
• mesh - turn on autoscaling just for the mesh box
• value - turn on autoscaling just for the value range.

It is available as both: a stream and a script command.