Slide

ज्ञान Jñāna

Ikaros

Quechua for: To blow smoke in order to heal

Cantos ancestrales de la Amazonía

Play

00:00 / 00:00

Ancient sounds & Sacred geometry

This ancient Indian Raag is rendered at the time when candles are put on. Its original name is Raag Kalyan and only during the Mughal's rule the name Yaman was introduced and became current. Raag Yaman's approximate age spans centuries, with its roots deeply embedded in the historical evolution of Indian classical music, making it one of the ancient and enduring raags in the Hindu tradition, inter alia. It is suggested that Yaman/Kalyan experienced a transformation credited to Abu'l Hasan Yamīn ud-Dīn Khusrau (≈ †1253; *1325), who not only gave it the name Yaman but also played a role in its evolution. The origins of the Yaman raag can be traced back to the Kalyaan Thaat, classifying it as an Aasreya Raag within this Thaat (see also Kaufmann, 1968). The tonal progressions in Yaman Raag often exhibit a zigzag pattern, featuring sequences with a gap of one or more notes. For instance, Wikipedia authors write that "this pattern frequently includes a preference for reversing the order of notes, such as DNS' mDN GmD RGm N,GR or MDNS' GmDN RGmD N,RGm D,N,GR." The process of rendering a raga involves certain mathematical and geometric concepts. For example, the division of the octave into a specific number of swaras (notes), the use of rhythmic cycles (talas), and the mathematical precision in the execution of ornamentations (gamakas) all contribute to the performance and æsthetics of a raga.
See also: Dandawate, Y. H., Kumari, P., & Bidkar, A. (2015). Indian instrumental music: Raga analysis and classification. 2015 1st International Conference on Next Generation Computing Technologies (NGCT), 725–729.

श्री यन् Sri Yantra

The Sri Yantra, also known as the Sri Chakra, is a sacred geometric pattern and a powerful symbol in Vedic traditions. It holds significant spiritual and philosophical meanings. It has ancient roots and is considered one of the oldest (archetypal) symbols with profound semiotic pertinence. The exact age of the Sri Yantra is challenging to ascertain. Its origins are often traced back to ancient Indian scriptures and practices, and it has been part of Hindu and Tantric traditions for millenia. Sources indicate that it originated over 5,000 years ago, possibly much older. Click here to view related references.
Geometric Precision:
The Sri Yantra is a complex geometric figure consisting of nine interlocking triangles that radiate from a central point (cf. Fibonacci sequence; see also Sisodiya, 2023). The precision and bilateral symmetry of the design represent the fundamental principles of cosmos (viz., order) and the underlying structure of the universe.
Symbolism:
The nine interwoven isosceles triangles in the Sri Yantra symbolise the divine feminine (yoni) and masculine (linga), representing Shakti or the cosmic energy.
The bindu (central point) represents the unmanifested absolute reality or the cosmic source from which existence emanates. It symboloises the original unity of the male and female form prior to creation.
The concentric circles around the bindu symbolise the layers of creation and the various levels of consciousness. Note that this synopsis cannot do any justice to the symbolic complexity of the yantra.
Mystical Powers:
The Sri Yantra is considered a mystical diagram that embodies spiritual and cosmic energies.
Meditating on the Sri Yantra is believed to enhance spiritual growth, bring about prosperity, and promote overall psychological well-being.
Tantric Practices:
In Tantric traditions, the Sri Yantra is used as a tool for meditation and ritual worship.
Each triangle and intersection point within the Sri Yantra corresponds to specific deities and energies.
Sacred Geometry:
The geometric patterns of the Sri Yantra are aligned with the principles of sacred geometry, emphasizing harmony, balance, and interconnectedness.
Yantra Puja:
The Sri Yantra is often used in Yantra Puja, a ritualistic worship where the practitioner focuses on the visual representation of the yantra to connect with higher spiritual energies.
Universal Harmony:
The intricate design of the Sri Yantra is believed to represent the harmonious interplay of cosmic forces and the unity of the material and spiritual realms.
In brevi, the Sri Yantra is a timeless symbol with deep spiritual significance, and its age underscores its relevance in various mystical and philosophical traditions. It serves as a focal point for meditation, worship, and spiritual contemplation for humans seeking a connection with the divine and the universal order.

Artwork by Luis Tamani

//JavaScript source code
"use strict";
const nbSqMin = 40; // number of squares in geometrical mean of width height
const nbSqMax = 100; // length of square side sqWidthMin..50
const DHUE = 1; // integer 1-10 - hue change by step
const DLUM = 3; // 0.1 - 5 - lightness change by step
const SPEED = 1;

let canv, ctx; // canvas and context

let maxx, maxy; // canvas dimensions

let sqWidth, sqRad; // square side length, quarter of circle radius (1/2 sqWidth)
let grid;
let nbx, nby;
let hnbx, hnby; // number of squares in the half of the width, height of the canvas

let groups;
let listReachable;

// for animation

let events;
let colorMode;

// shortcuts for Math.
const mrandom = Math.random;
const mfloor = Math.floor;
const mround = Math.round;
const mceil = Math.ceil;
const mabs = Math.abs;
const mmin = Math.min;
const mmax = Math.max;

const mPI = Math.PI;
const mPIS2 = Math.PI / 2;
const mPIS3 = Math.PI / 3;
const m2PI = Math.PI * 2;
const m2PIS3 = (Math.PI * 2) / 3;
const msin = Math.sin;
const mcos = Math.cos;
const matan2 = Math.atan2;

const mhypot = Math.hypot;
const msqrt = Math.sqrt;

const rac3 = msqrt(3);
const rac3s2 = rac3 / 2;

//------------------------------------------------------------------------

function alea(mini, maxi) {
  // random number in given range

  if (typeof maxi == "undefined") return mini * mrandom(); // range 0..mini

  return mini + mrandom() * (maxi - mini); // range mini..maxi
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
function intAlea(mini, maxi) {
  // random integer in given range (mini..maxi - 1 or 0..mini - 1)
  //
  if (typeof maxi == "undefined") return mfloor(mini * mrandom()); // range 0..mini - 1
  return mini + mfloor(mrandom() * (maxi - mini)); // range mini .. maxi - 1
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

function removeElement(array, element) {
  let idx = array.indexOf(element);
  if (idx == -1) throw "Bug ! indexOf -1 in removeElement";
  array.splice(idx, 1);
} // removeElement

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
function randomElement(array) {
  return array[intAlea(0, array.length)];
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
function arrayShuffle(array) {
  /* randomly changes the order of items in an array
           only the order is modified, not the elements
        */
  let k1, temp;
  for (let k = array.length - 1; k >= 1; --k) {
    k1 = intAlea(0, k + 1);
    temp = array[k];
    array[k] = array[k1];
    array[k1] = temp;
  } // for k
  return array;
} // arrayShuffle

//------------------------------------------------------------------------

function Square(kx, ky, color) {
  /* constructor */

  this.color = color ? color : `hsl(${intAlea(360)},100%,50%)`;
  this.kx = kx;
  this.ky = ky;
  this.kxc = kx - hnbx;
  this.kyc = ky - hnby;

  this.xc = maxx / 2 + this.kxc * sqWidth; // center of square
  this.yc = maxy / 2 + this.kyc * sqWidth;
} // Square
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

Square.prototype.fillSquare = function (evolColor) {
  const side = sqWidth * 0.707;
  const hSide = side / 2;
  ctx.fillStyle = `hsl(${evolColor.hue}, 100%,${evolColor.lum}% )`;
  ctx.beginPath();
  ctx.arc(this.xc, this.yc, side, 0, m2PI);
  ctx.fill();
  ctx.strokeStyle = "#000";
  ctx.lineWidth = 1;
  ctx.stroke();
}; // Square.prototype.fillSquare

//------------------------------------------------------------------------

let animate;

{
  // scope for animate

  let animState = 0;
  let listReachable;
  let currCell, evolColor;

  animate = function (tStamp) {
    let tinit;
    let event;
    let neighGroups;

    event = events.shift();
    if (event && event.event == "reset") animState = 0;
    if (event && event.event == "click") animState = 0;
    window.requestAnimationFrame(animate);

    tinit = performance.now();
    do {
      switch (animState) {
        case 0:
          if (startOver()) {
            ++animState;
            evolColor = {};
            evolColor.hue = intAlea(360);
            evolColor.dhue = intAlea(2) ? DHUE : 360 - DHUE;
            evolColor.lum = intAlea(40, 80);
            evolColor.dlum = intAlea(2) ? -DLUM : DLUM;
            evolColor.width = alea(0.5, 2.5);
            evolColor.dWidth = 0.1;
            evolColor = nextColor(evolColor);
          }
          break;

        case 1:
          currCell = grid[hnby][hnbx];
          currCell.from = -1;
          currCell.evolColor = evolColor;
          listReachable = [currCell];
          ++animState;

        case 2:
          if (listReachable.length == 0) {
            animState += 2; // finished !
            break;
          }
          currCell = listReachable.shift();
          //        evolColor = currCell.evolColor;
          ++animState;
        // break;

        case 3:
          currCell.group.forEach((cell) => cell.fillSquare(evolColor));
          // make list of all neighbour groups
          neighGroups = new Set();
          currCell.group.forEach((cell) => {
            cell.neighbours.forEach((neighCell) => {
              if (!neighCell.evolColor)
                // keep only undrawn cells;
                neighGroups.add(neighCell.group);
            }); // cell.neighbours.forEach
          }); // currCell.group.forEach

          if (neighGroups.size == 0) {
            // no neighbours available
            --animState; // go back and fetch in listReachable
            break;
          }

          // put those groups in a random order
          neighGroups = arrayShuffle([...neighGroups]); // change into Array
          // prepare future color
          evolColor = nextColor(evolColor);
          // attribute new color to all neighbours (all cells of all neighbour groups)
          neighGroups.forEach((group) => {
            group.forEach((cell) => {
              cell.evolColor = evolColor;
              cell.from = -1;
            }); // group.forEach
          }); // neighGroups.forEach

          for (let k = 1; k < neighGroups.length; ++k) {
            listReachable.push([...neighGroups[k]][0]); // push 1 cell of every group - but first
          }
          currCell = [...neighGroups[0]][0];
          break;
      } // switch
    } while (
      (animState == 2 || animState == 3) &&
      performance.now() - tinit < SPEED
    );
  }; // animate
} // scope for animate

//------------------------------------------------------------------------

function createGrid() {
  let kx1, ky1, cell;

  grid = [];

  for (let ky = 0; ky < nby; ++ky) {
    grid[ky] = [];
    for (let kx = 0; kx < nbx; ++kx) {
      grid[ky][kx] = new Square(kx, ky);
    } // for kx
  } // for ky

  // calculate neighbours
  for (let ky = 0; ky < nby; ++ky) {
    for (let kx = 0; kx < nbx; ++kx) {
      cell = grid[ky][kx];
      cell.neighbours = [];
      ky1 = ky - 1; // neighbour side 0
      if (ky1 >= 0) cell.neighbours[0] = grid[ky1][kx];
      kx1 = kx + 1; // neighbour side 1
      if (kx1 < nbx) cell.neighbours[1] = grid[ky][kx1];
      ky1 = ky + 1; // neighbour side 2
      if (ky1 < nby) cell.neighbours[2] = grid[ky1][kx];
      kx1 = kx - 1; // neighbour side 3
      if (kx1 >= 0) cell.neighbours[3] = grid[ky][kx1];
    } // for kx
  } // for ky

  // create groups

  for (let ky = 0; ky < nby; ++ky) {
    for (let kx = 0; kx < nbx; ++kx) {
      cell = grid[ky][kx];
      if (cell.group) continue;
      cell.group = new Set([cell]); // myself
      addToGroup(cell.group, hnbx - cell.kxc, cell.ky);
      addToGroup(cell.group, cell.kx, hnby - cell.kyc);
      addToGroup(cell.group, hnbx - cell.kxc, hnby - cell.kyc);
      addToGroup(cell.group, hnbx + cell.kyc, hnby + cell.kxc);
      addToGroup(cell.group, hnbx + cell.kyc, hnby - cell.kxc);
      addToGroup(cell.group, hnbx - cell.kyc, hnby + cell.kxc);
      addToGroup(cell.group, hnbx - cell.kyc, hnby - cell.kxc);
    } // for kx
  } // for ky
} // createGrid

//------------------------------------------------------------------------
function addToGroup(group, kx, ky) {
  if (kx < 0 || ky < 0 || kx >= nbx || ky >= nby) return; // out of grid, do not add
  group.add(grid[ky][kx]);
  grid[ky][kx].group = group;
} // addToGroup

//------------------------------------------------------------------------

function nextColor(evolColor) {
  let hue = evolColor.hue;
  let dhue = evolColor.dhue;
  let lum = evolColor.lum;
  let dlum = evolColor.dlum;
  let width = evolColor.width;
  let dWidth = evolColor.dWidth;

  let color;
  switch (colorMode) {
    case 0:
      color = `hsl(${hue},100%,50%)`;
      hue = (hue + dhue) % 360;
      lum = 50;
      break;
    case 1:
      color = `hsl(${hue},100%,${lum}%)`;
      lum += dlum;
      if (lum > 80) dlum = -mabs(dlum);
      if (lum < 40) dlum = mabs(dlum);
      break;
    case 2:
      color = `hsl(${hue},100%,${lum}%)`;
      lum += dlum;
      if (lum > 80) dlum = -mabs(dlum);
      if (lum < 40) dlum = mabs(dlum);
      hue = (hue + dhue) % 360;
      break;
  } // switch
  width += dWidth;
  if (width > 2.5) dWidth = -mabs(dWidth);
  if (width < 0.5) dWidth = mabs(dWidth);

  return {
    hue: hue,
    dhue: dhue,
    lum: lum,
    dlum: dlum,
    width: width,
    dWidth: dWidth,
    color: color
  };
} // returnColor

//------------------------------------------------------------------------

function startOver() {
  // canvas dimensions

  maxx = window.innerWidth;
  maxy = window.innerHeight;

  canv.width = maxx;
  canv.height = maxy;
  ctx.lineJoin = "bevel";
  ctx.lineCap = "round";

  sqWidth = msqrt(maxx * maxy) / alea(nbSqMin, nbSqMax);
  sqRad = sqWidth / 2;

  hnby = mfloor(maxy / sqWidth / 2); // the full array has 2 * hnbx + 1 rows
  hnbx = mfloor(maxx / sqWidth / 2);
  nbx = 1 + 2 * hnbx;
  nby = 1 + 2 * hnby;

  if (nbx < 3 || nby < 3) return false;
  ctx.clearRect(0, 0, maxx, maxy);

  if (colorMode == undefined) colorMode = 2;
  else colorMode = intAlea(3);
  createGrid();

  return true;
} // startOver

//------------------------------------------------------------------------

function mouseClick(event) {
  events.push({ event: "click" });
} // mouseMove

//------------------------------------------------------------------------
//------------------------------------------------------------------------
// beginning of execution

{
  canv = document.createElement("canvas");
  canv.style.position = "absolute";
  document.body.appendChild(canv);
  ctx = canv.getContext("2d");
} // création CANVAS
canv.addEventListener("click", mouseClick); // just for initial position
events = [{ event: "reset" }];
requestAnimationFrame(animate);
// Credit: https://codepen.io/Dillo/pen/OJGbpqz