void Matrix_drawAsSquares (Matrix me, Graphics g, double xmin, double xmax, double ymin, double ymax, int garnish) {
Graphics_Colour colour = Graphics_inqColour (g);
long ixmin, ixmax, iymin, iymax;
if (xmax <= xmin) {
xmin = my xmin;
xmax = my xmax;
}
long nx = Matrix_getWindowSamplesX (me, xmin, xmax, &ixmin, &ixmax);
if (ymax <= ymin) {
ymin = my ymin;
ymax = my ymax;
}
long ny = Matrix_getWindowSamplesY (me, ymin, ymax, &iymin, &iymax);
double min, max = nx > ny ? nx : ny;
double dx = (xmax - xmin) / max, dy = (ymax - ymin) / max;
Graphics_setInner (g);
Graphics_setWindow (g, xmin, xmax, ymin, ymax);
Matrix_getWindowExtrema (me, ixmin, ixmax, iymin, iymax, & min, & max);
double wAbsMax = fabs (max) > fabs (min) ? fabs (max) : fabs (min);
for (long i = iymin; i <= iymax; i++) {
double y = Matrix_rowToY (me, i);
for (long j = ixmin; j <= ixmax; j++) {
double x = Matrix_columnToX (me, j);
double d = 0.95 * sqrt (fabs (my z[i][j]) / wAbsMax);
if (d > 0) {
double x1WC = x - d * dx / 2, x2WC = x + d * dx / 2;
double y1WC = y - d * dy / 2, y2WC = y + d * dy / 2;
if (my z[i][j] > 0) {
Graphics_setColour (g, Graphics_WHITE);
}
Graphics_fillRectangle (g, x1WC, x2WC, y1WC, y2WC);
Graphics_setColour (g, colour);
Graphics_rectangle (g, x1WC, x2WC , y1WC, y2WC);
}
}
}
Graphics_setGrey (g, 0.0);
Graphics_unsetInner (g);
if (garnish) {
Graphics_drawInnerBox (g);
Graphics_marksLeft (g, 2, true, true, false);
if (ymin * ymax < 0.0) {
Graphics_markLeft (g, 0.0, true, true, true, nullptr);
}
Graphics_marksBottom (g, 2, true, true, false);
if (xmin * xmax < 0.0) {
Graphics_markBottom (g, 0.0, true, true, true, nullptr);
}
}
}
void Graphics_matrixAsSquares (Graphics g, double **matrix, long numberOfRows, long numberOfColumns, double zmin, double zmax, double cellSizeFactor, int randomFillOrder) {
long numberOfCells = numberOfRows * numberOfColumns;
autoPermutation p = Permutation_create (numberOfCells);
if (randomFillOrder) {
Permutation_permuteRandomly_inline (p.peek(), 1, numberOfCells);
}
double zAbsMax = fabs (zmax) > fabs (zmin) ? fabs (zmax) : fabs (zmin);
Graphics_Colour colour = Graphics_inqColour (g);
double x1WC, x2WC, y1WC, y2WC;
Graphics_inqWindow (g, &x1WC, &x2WC, &y1WC, &y2WC);
double dx = fabs (x2WC - x1WC) / numberOfColumns;
double dy = fabs (y2WC - y1WC) / numberOfRows;
for (long i = 1; i <= numberOfCells; i++) {
long index = Permutation_getValueAtIndex (p.peek(), i);
long irow = (index - 1) / numberOfColumns + 1;
long icol = (index - 1) % numberOfColumns + 1;
double z = matrix[irow][icol];
z = z < zmin ? zmin : z;
z = z > zmax ? zmax : z;
double zweight = sqrt (fabs (z) / zAbsMax); // Area length^2)
double xcenter = (icol - 0.5) * dx;
double ycenter = (irow - 0.5) * dy;
double x1 = x1WC + xcenter - zweight * 0.5 * dx * cellSizeFactor;
x1 = x1 < x1WC ? x1WC : x1;
double x2 = x1WC + xcenter + zweight * 0.5 * dx * cellSizeFactor;
x2 = x2 > x2WC ? x2WC : x2;
double y1 = y1WC + ycenter - zweight * 0.5 * dy * cellSizeFactor;
y1 = y1 < y1WC ? y1WC : y1;
double y2 = y1WC + ycenter + zweight * 0.5 * dy * cellSizeFactor;
y2 = y2 > y2WC ? y2WC : y2;
if (z > 0) {
Graphics_setColour (g, Graphics_WHITE);
}
Graphics_fillRectangle (g, x1, x2, y1, y2);
Graphics_setColour (g, colour);
Graphics_rectangle (g, x1, x2 , y1, y2);
}
}
void TableOfReal_drawAsSquares (TableOfReal me, Graphics graphics, long rowmin, long rowmax,
long colmin, long colmax, int garnish)
{
double dx = 1, dy = 1;
Graphics_Colour colour = Graphics_inqColour (graphics);
fixRows (me, & rowmin, & rowmax);
fixColumns (me, & colmin, & colmax);
Graphics_setInner (graphics);
Graphics_setWindow (graphics, colmin - 0.5, colmax + 0.5, rowmin - 0.5, rowmax + 0.5);
double datamax = my data [rowmin] [colmin];
for (long irow = 1; irow <= my numberOfRows; irow ++)
for (long icol = 1; icol <= my numberOfColumns; icol ++)
if (fabs (my data [irow] [icol]) > datamax) datamax = fabs (my data [irow] [icol]);
for (long irow = rowmin; irow <= rowmax; irow ++) {
double y = rowmax + rowmin - irow;
for (long icol = colmin; icol <= colmax; icol ++) {
double x = icol;
/* two neighbouring squares should not touch -> 0.95 */
double d = 0.95 * sqrt (fabs (my data [irow] [icol]) / datamax);
double x1WC = x - d * dx / 2, x2WC = x + d * dx / 2;
double y1WC = y - d * dy / 2, y2WC = y + d * dy / 2;
if (my data [irow] [icol] > 0) Graphics_setColour (graphics, Graphics_WHITE);
Graphics_fillRectangle (graphics, x1WC, x2WC, y1WC, y2WC);
Graphics_setColour (graphics, colour);
Graphics_rectangle (graphics, x1WC, x2WC , y1WC, y2WC);
}
}
Graphics_setGrey (graphics, 0.0);
Graphics_unsetInner (graphics);
if (garnish) {
for (long irow = rowmin; irow <= rowmax; irow ++) if (my rowLabels [irow])
Graphics_markLeft (graphics, rowmax + rowmin - irow, 0, 0, 0, my rowLabels [irow]);
for (long icol = colmin; icol <= colmax; icol ++) if (my columnLabels [icol])
Graphics_markTop (graphics, icol, 0, 0, 0, my columnLabels [icol]);
}
}
void FFNet_drawActivation (FFNet me, Graphics g) {
long node = 1, maxNumOfUnits = my nUnitsInLayer[0];
int dxIsFixed = 1;
Graphics_Colour colour = Graphics_inqColour (g);
double dy = 1.0 / (my nLayers + 1);
Graphics_setInner (g);
Graphics_setWindow (g, 0.0, 1.0, 0.0, 1.0);
for (long i = 1; i <= my nLayers; i++) {
if (my nUnitsInLayer[i] > maxNumOfUnits) {
maxNumOfUnits = my nUnitsInLayer[i];
}
}
double dx = 1.0 / maxNumOfUnits;
double r1 = dx / 2.0; /* May touch when neighbouring activities are both 1 (very rare). */
for (long i = 0; i <= my nLayers; i++, node++) {
double dx2 = dx, x2WC, y2WC = dy / 2.0 + i * dy;
double x2 = (maxNumOfUnits - my nUnitsInLayer[i] + 1) * dx2 / 2.0;
if (! dxIsFixed) {
dx2 = 1.0 / my nUnitsInLayer[i];
x2 = dx2 / 2.0;
}
x2WC = x2;
for (long j = 1; j <= my nUnitsInLayer[i]; j++, node++) {
double activity = my activity[node];
double radius = r1 * (fabs (activity) < 0.05 ? 0.05 : fabs (activity));
/*Graphics_setColour (g, activity < 0 ? Graphics_BLACK : Graphics_RED);*/
Graphics_circle (g, x2WC, y2WC, radius);
if (activity < 0) {
Graphics_fillCircle (g, x2WC, y2WC, radius);
}
x2WC += dx2;
}
}
Graphics_setColour (g, colour);
Graphics_unsetInner (g);
}
