main.cpp

Go to the documentation of this file.

// MIT License
//
// Copyright (c) 2020 Ian Parberry
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.

#define _USE_MATH_DEFINES
#include <math.h>

#include <stdio.h>
#include <string>

const float PI = 3.14159265358979323846f; 

// Helper fuctions.

#pragma region helpers


bool OpenSVG(FILE*& output, const std::string& fname, size_t w, size_t h){
  const std::string s = fname + ".svg";
  
#ifdef _MSC_VER //Visual Studio 
  fopen_s(&output, s.c_str(), "wt");
#else
  output = fopen(s.c_str(), "wt");
#endif
  
  if(output != nullptr){ //write header to file
    fprintf(output, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"); //xml tag

    fprintf(output, "<svg width=\"%lu\" height=\"%lu\" ", w, w); //svg tag
    fprintf(output, "viewBox=\"0 0 %lu %lu\" ", w, w);
    fprintf(output, "xmlns=\"http://www.w3.org/2000/svg\">\n");
    
    fprintf(output, "<!-- Created by Ian Parberry -->\n"); //author comment
     
    return true; //success
  } //if

  return false; //failure
} //OpenSVG


void CloseSVG(FILE*& output){
  if(output != nullptr){
    fprintf(output, "</svg>\n"); //close the svg tag
    fclose(output);
    output = nullptr;
  } //if
} //CloseSVG

#pragma endregion helpers

// Optical Illusion 1 - circles of squares.

#pragma region Illusion1


void DrawCircleOfSquares(FILE* output, size_t cx, size_t cy, float r,
  size_t sw, bool parity)
{
  //number of squares on circle, must be even
  const size_t n = (size_t)ceil((2*PI*r)/(1.5f*sw)) & 0xFFFFFFFE; 

  const float dtheta = 2*PI/n; //angle delta to next square
  float theta = 0; //angle to current square

  for(size_t i=0; i<n; i++){ //for each square
    const float x = r*cosf(theta); //square center x
    const float y = r*sinf(theta); //square center y
    const float phi = 12*(parity? 1: -1) + 180*theta/PI; //square orientation

    fprintf(output, "<g transform=\"translate(%0.1f %0.1f)", x + sw/2, y + sw/2); //translate
    fprintf(output, "rotate(%0.1f %lu %lu)\">", phi, cx, cy); //rotate
    fprintf(output, "<rect width=\"%lu\" height=\"%lu\" ", sw, sw); //rectangle
    if(i&1)fprintf(output, "class=\"b\""); //black
    else fprintf(output, "class=\"w\""); //white
    fprintf(output, "/>"); //close rect tag
    fprintf(output, "</g>\n"); //close group

    theta += dtheta; //next square
  } //for
} //DrawCircleOfSquares


void OpticalIllusion1(const std::string& fname, size_t w, size_t n,
  float r0, float dr, size_t sw, const char dark[], const char light[],
  const char bgclr[])
{
  const size_t cx = w/2 - sw/2; //center x coordinate
  const size_t cy = cx; //center y coordinate
  FILE* output = nullptr; //output file pointer

  if(OpenSVG(output, fname, w, w)){
    //style tag
    fprintf(output, "<style>"); //open style tag
    fprintf(output, "rect{fill:none;stroke-width:3}"); //rectangle
    fprintf(output, "rect.b{x:%lu;y:%lu;stroke:%s;}", cx, cy, dark); //black rectangle
    fprintf(output, "rect.w{x:%lu;y:%lu;stroke:%s;}", cx, cy, light); //white rectangle
    fprintf(output, "</style>\n"); //close style tag
    
    //background
    fprintf(output, "<rect width=\"%lu\" height=\"%lu\" ", w, w); //rectangle
    fprintf(output, "style=\"fill:%s\"/>\n", bgclr); //fill
  
    for(size_t i=0; i<n; i++) //for each circle of squares
      DrawCircleOfSquares(output, cx, cy, r0 + i*dr, sw, i&1); //draw it
       
    CloseSVG(output); //clean up and exit
  } //if
} //OpticalIllusion1

#pragma endregion Illusion1

// Optical Illusion 2 - circles of circles of ellipses.

#pragma region Illusion2


void SelectEllipseColor(FILE* output, size_t i, bool parity){
  const size_t j = i%4;
  if((parity && j == 0) || (!parity && j == 2))
    fprintf(output, "class=\"b\""); //black ellipse
  else if((parity && j == 2) || (!parity && j == 0))
    fprintf(output, "class=\"w\""); //white ellipse
} //SelectEllipseColor


void DrawCircleOfEllipses(FILE* output, size_t cx, size_t cy, float r,
  float r0, float r1, size_t n, float theta, float dtheta, bool parity,
  size_t flip=999999)
{
  for(size_t i=0; i<n; i++){ //for each ellipse
    const float x = r*cosf(theta); //ellipse center x
    const float y = r*sinf(theta); //ellipse center y
    const float phi = 90 + 180*theta/PI; //ellipse orientation

    fprintf(output, "<g transform=\"translate(%0.1f %0.1f)", x, y); //translate
    fprintf(output, "rotate(%0.1f %lu %lu)\">", phi, cx, cy); //rotate
    fprintf(output, "<ellipse cx=\"400\" cy=\"400\" "); //ellipse
    fprintf(output, "rx=\"%0.1f\" ry=\"%0.1f\" ", r0, r1); //ellipse
    
    SelectEllipseColor(output, i, parity);

    fprintf(output, "/>"); //close rect tag
    fprintf(output, "</g>\n"); //close group

    theta += dtheta; //next ellipse
    if(i == flip)parity = !parity; //flip parity if we need to
  } //for
} //DrawCircleOfEllipses


void DrawTripleCircle(FILE* output, size_t cx, size_t cy, float r,
  float r0, float r1, size_t n, bool flip=false)
{
  const float dtheta = PI/n; //angle delta to next ellipse
  float theta = (flip? PI: -PI)/2; //angle to next ellipse
  n *= 2; //include spaces

  DrawCircleOfEllipses(output, cx, cy, r, r0, r1, n, theta, dtheta, true);  
  DrawCircleOfEllipses(output, cx, cy, r - r1, r0, r1, n, 
    theta + dtheta, dtheta, true, n/2 - 1);  
  DrawCircleOfEllipses(output, cx, cy, r + r1, r0, r1, n, 
    theta + dtheta, dtheta, false, n/2 - 2);
} //DrawTripleCircle


void OpticalIllusion2(const std::string& fname, size_t w, size_t n,
  float r, float r0, float r1, const char dark[], const char light[],
  const char bgclr[])
{
  const size_t cx = w/2; //center x coordinate
  const size_t cy = cx; //center y coordinate
  FILE* output = nullptr; //output file pointer

  if(OpenSVG(output, fname, w, w)){
    //style tag
    fprintf(output, "<style>"); //open style tag
    fprintf(output, "ellipse{fill:none;stroke-width:3}"); //ellipse
    fprintf(output, "ellipse.b{cx:%lu;cy:%lu;stroke:none;fill:%s;}",
      cx, cy, dark);  //dark ellipse
    fprintf(output, "ellipse.w{cx:%lu;cy:%lu;stroke:none;fill:%s;}",
      cx, cy, light); //light ellipse
    fprintf(output, "</style>\n"); //close style tag
    
    //background
    fprintf(output, "<rect width=\"%lu\" height=\"%lu\" ", w, w); //rectangle
    fprintf(output, "style=\"fill:%s\"/>\n", bgclr); //fill
  
    DrawTripleCircle(output, cx, cy, r, r0, r1, 36);
    DrawTripleCircle(output, cx, cy, r - 64, 0.8f*r0, 0.8f*r1, 36, true);

    CloseSVG(output); //clean up and exit
  } //if
} //OpticalIllusion2

#pragma region Illusion2



int main(){
  OpticalIllusion1("output1", 800, 4, 100.0f, 72.0f, 24,
    "black", "white", "gray");
  OpticalIllusion1("output1a", 800, 4, 100.0f, 72.0f, 24,
    "blue", "yellow", "forestgreen");
  OpticalIllusion2("output2", 800, 3, 300.0f, 12.0f, 6.0f,
    "black", "white", "gray");
  OpticalIllusion2("output2a", 800, 3, 300.0f, 12.0f, 6.0f,
    "blue", "yellow", "forestgreen");

  return 0;
} //main