Diferencia entre revisiones de «Imagen Escrita»

De Casiopea
Sin resumen de edición
Sin resumen de edición
Línea 1: Línea 1:
<div style="text-align: center; text-align-last: center; -moz-text-align-last: center">
<processingjs>
/**
*
*  Pyxis - e[ad]
*  2014
*
*/
// Variables
int numC = 123;
int numL = 3210;
float minDist    = 120;
float globalDiam = 290;
float maxAlpha = 10;
Star[] p;  // constelations
Star[] pp; // lonely stars
// Star
class Star {
  float x, y, ang, adv, diam, alpha;
  Star(float _x, float _y) {
    x = _x;
    y = _y;
    diam = random(1, 5);
    alpha = random(10, maxAlpha);
    ang = random(TWO_PI);
    adv = random(1);
  }
  void go() {
    if (x > 10 && y > 10) {
      move();
      paint();
    }
  }
  void move() {
    x += cos(ang) * adv;
    y += sin(ang) * adv;
    // float n = (noise(x,y) - .5) * .5;
    // ang += n;
    if (dist(x, y, width/2, height/2) > globalDiam) {
      float ANG = atan2((x - (width/2.0)), (y - (height/2.0))) * -1 + HALF_PI;
      ang += (ang - ANG);
    }
  }
  void paint() {
    fill(0, alpha);
    ellipse(x, y, diam, diam);
  }
}
// -------------------------------
void setup() {
  size(700, 700);
  p = new Star[numC];
  pp = new Star[numL];
  int n = 0;
  // build constelations
  while (n < numC) {
    float x = random(width);
    float y = random(height);
    float d = dist(x, y, width/2, height/2);
    if (d < globalDiam) {
      p[n] = new Star(x, y);
      n ++;
    }
  }
  n = 0;
  // build lonely stars
  while (n < numL) {
    float x = random(width);
    float y = random(height);
    float d = dist(x, y, width/2, height/2);
    if (d < globalDiam) {
      pp[n] = new Star(x, y);
      pp[n].diam = random(1, 2);
      pp[n].adv = random(.5);
      n ++;
    }
  }
  background(255);
}
void draw() {
 
  noStroke();
  // animate + paint lonely stars
  for (int i = 0; i < pp.length; i++) {
    pp[i].go();
  }
  // animate + paint constelated stars
  for (int i = 0; i < p.length; i++) {
    p[i].go();
  }
  // paint constelations
  for (int i = 0; i < p.length; i++) {
    for (int j = p.length - 1; j > i; j--) {
      float d = dist(p[i].x, p[i].y, p[j].x, p[j].y);
      if (d < minDist) {
        float a = map(d, 0, minDist, maxAlpha, 0);
        stroke(0, a);
        line(p[i].x, p[i].y, p[j].x, p[j].y);
      }
    }
  }
 
  noStroke();
  fill(255, 20);
  rect(0, 0, width, height);
}
</processingjs>
</div>
{{Asignatura
{{Asignatura
|Nombre=Imagen Escrita: Introducción a la Programación Gráfica
|Nombre=Imagen Escrita: Introducción a la Programación Gráfica

Revisión del 18:00 5 sep 2015

<processingjs> /**

*
*  Pyxis - e[ad]
*  2014
*
*/


// Variables

int numC = 123; int numL = 3210;

float minDist = 120; float globalDiam = 290; float maxAlpha = 10;

Star[] p; // constelations Star[] pp; // lonely stars

// Star

class Star {

 float x, y, ang, adv, diam, alpha;
 Star(float _x, float _y) {
   x = _x;
   y = _y;
   diam = random(1, 5);
   alpha = random(10, maxAlpha);
   ang = random(TWO_PI);
   adv = random(1);
 }
 void go() {
   if (x > 10 && y > 10) {
     move();
     paint();
   }
 }
 void move() {
   x += cos(ang) * adv;
   y += sin(ang) * adv;
   // float n = (noise(x,y) - .5) * .5;
   // ang += n;
   if (dist(x, y, width/2, height/2) > globalDiam) {
     float ANG = atan2((x - (width/2.0)), (y - (height/2.0))) * -1 + HALF_PI;
     ang += (ang - ANG);
   }
 }
 void paint() {
   fill(0, alpha);
   ellipse(x, y, diam, diam);
 }

}

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

void setup() {

 size(700, 700);
 p = new Star[numC];
 pp = new Star[numL];
 int n = 0;
 // build constelations
 while (n < numC) {
   float x = random(width);
   float y = random(height);
   float d = dist(x, y, width/2, height/2);
   if (d < globalDiam) {
     p[n] = new Star(x, y);
     n ++;
   }
 }
 n = 0;
 // build lonely stars
 while (n < numL) {
   float x = random(width);
   float y = random(height);
   float d = dist(x, y, width/2, height/2);
   if (d < globalDiam) {
     pp[n] = new Star(x, y);
     pp[n].diam = random(1, 2);
     pp[n].adv = random(.5);
     n ++;
   }
 }
 background(255);

}

void draw() {

 noStroke();
 // animate + paint lonely stars
 for (int i = 0; i < pp.length; i++) {
   pp[i].go();
 }
 // animate + paint constelated stars
 for (int i = 0; i < p.length; i++) {
   p[i].go();
 }
 // paint constelations
 for (int i = 0; i < p.length; i++) {
   for (int j = p.length - 1; j > i; j--) {
     float d = dist(p[i].x, p[i].y, p[j].x, p[j].y);
     if (d < minDist) {
       float a = map(d, 0, minDist, maxAlpha, 0);
       stroke(0, a);
       line(p[i].x, p[i].y, p[j].x, p[j].y);
     }
   }
 }
 
 noStroke();
 fill(255, 20);
 rect(0, 0, width, height);

} </processingjs>




Clave(es)ARQ 060
Créditos2
Profesor(es)Herbert Spencer
Del ProgramaArquitectura,Diseño
Ciclo FormativoCiclo del Oficio
Área de EstudioÁrea Fundamental, Línea del Lenguaje Tecnológico
CurrículumAjuste Curricular 2015
HomologadaGráfica Digital
Régimensemestral
Período Académicoprimero
Horas PUCV1 teóricas + 1 de taller + 0 de ayudantía + 2,5 de trabajo autónomo
* Las horas PUCV corresponden a periodos académicos de 35 minutos.

Descripción y Contextualización de la Asignatura en el Currículo

Este curso corresponde a una introducción al diseño de software como una herramienta de expresión plástica; ya sea estática, cinética o interactiva. Aquí trataremos los fundamentos de la forma computacional y los principios de la programación gráfica basándonos en el lenguaje Processing. Los estudiantes se familiarizarán con algoritmos básicos, geometría computacional y simulación cinemática además de los conceptos básicos y necesarios para construir programas; como los diferentes tipos de datos, iteraciones, funciones y el concepto de objeto, entre otros. Este ramo busca equilibrar las nociones matemáticas abstractas de la computación con la expresión plástica y formal de los algoritmos, permitiendo una mirada más amplia, artística y lúdica de la forma computacional. Tener experiencia previa en programación no es un requisito para este curso.

Contenidos o Unidades de Aprendizaje

  1. Breve historia de la programación
  2. Contextualización histórica cyberpunk y cultura DIY
  3. Pensamiento algorítmico en el arte
  4. Entorno de desarrollo Processing
  5. Estructuras de datos
  6. Ciclos y Repeticiones
  7. Funciones propias
  8. Arreglos
  9. Objetos
  10. Elementos de interactividad
  11. Proyecciones: formas de extender y continuar el aprendizaje

Resultados de Aprendizaje

Una vez completada la asignatura, el o la estudiante será capaz de:

Competencias
Fundamentales
  1. Pensamiento abstracto
  2. Razonamiento lógico y jerárquico
  3. Familiaridad y manejo de conceptos matemáticos y computacionales
Competencias
Disciplinares
  1. Integración del razonaminto lógico (logos) y el razonamiento plástico (eros-pathos) en un ethos procesual de construcción de forma
  2. Capacidad de dividir un proceso en pasos
  3. Capacidad de explorar y generar variaciones a partir de una idea matriz
Competencias
Profesionales
  1. Manejo y aplicación de conceptos programáticos
  2. Producción de piezas plásticas e interactivas
  3. Manejo de entorno de desarrollo Processing

Actividades de Aprendizaje

  1. Presentaciones en modalidad de ponencia
  2. Talleres prácticos, tomando casos, explicando sus partes y desglosando sus métodos
  3. Reuniones individuales o grupales con el profesor
  4. Realización de proyectos individuales o grupales

Evaluación de los Resultados de Aprendizaje

  1. Constancia y cumplimiento de los encargos periódicos
  2. Creatividad entendida en este curso como la capacidad de conjeturar y explorar yendo más allá de la literalidad del ejemplo. Al no existir resultados correctos o falsos (como valor mensurable), nos remitiremos a sus dimensiones cualitativas
  3. ya sean en términos escriturales-estructurales (elegancia) o expresivo-plásticos (formales-idiosincráticos)
  4. Ciudadanía entendida como el sentido de colaboración y reciprocidad con el taller, manifestándose en disponibilidad y capacidad de entregar conocimientos y compartir código, reconociendo y citando las fuentes según sea el caso.

Bibliografía y Otros Recursos para el Aprendizaje

Processing: A Programming Handbook for Visual Designers and Artists
The Nature of Code. Daniel Shiffman

Herramietas


Cursos Realizados

  1. LC0: 2007(Año: 2 007)
  2. Processing: LC0(Año: 2 007)
  3. LC0: 2009(Año: 2 009)
  4. Imagen Escrita 2012(Año: 2 012)
  5. Imagen Escrita 2013 - ARQ(Año: 2 013)
  6. Imagen Escrita 2013 - DIS(Año: 2 013)
  7. Imagen Escrita 2017(Año: 2 017)
  8. Imagen Escrita 2018(Año: 2 018)
  9. Imagen Escrita 2019(Año: 2 019)
  10. Imagen Escrita 2019 T2(Año: 2 019)
  11. Imagen Escrita 2019 T1(Año: 2 019)
  12. Imagen Escrita 2020(Año: 2 020)
  13. Imagen Escrita 2021(Año: 2 021)
  14. Imagen Escrita 2022(Año: 2 022)
  15. Imagen Escrita 2023(Año: 2 023)
  16. Imagen Escrita: Espacios de Información(Año: 2 023)