A Wallpaper That Scales

First of all I would like to wish anyone who reads this blog or who is interested in mid-century patterns a very happy New Year 2016.

This pattern, maybe you could call it my New Year pattern, is designed using mid-century themes and, of course, mid-century colours. The pattern was created in code using Processing and, I have to be honest, I think in all probability that it was created quicker and easier than it would have been using drawing software.

You will be pleased to know that my elbow is continuing to improve to the point where I can use the mouse right-handed and I could probably go back to drawing. As I may have explained, I did a lot of computer coding a few years back and I also was involved with Processing when it first appeared, writing part of a textbook for the Open University. I have decided that I am enjoying creating artwork using Processing without having to worry about the code that I use and so I will continue into the New Year making some of these patterns that way.

On our Flickr page, which is here, you can see larger versions of the above together with another illustration which shows the pattern at quite a different scale which gives it a very different look to a new room set that I recently created in Cinema 3D.

color manilla ;
color jasmine ;
color montella ;
color gbrown ;
int w = 500 ;
void setup() {
 size(1000, 1000) ;
 
 // colors
 manilla = (#EED6AC) ;
 jasmine = (#F0DA5E) ;
 montella = color(#464130) ;
 gbrown = color(#945524) ; // golden brown
 
 background(manilla) ;
 
 // drawGuides() ;
 
 drawCircle(250, 250) ;
 drawCircle(750, 250) ;
 drawCircle(250, 750) ;
 drawCircle(750, 750) ;
 
 // shape
 for(int i = 250 ; i < width ; i += 500) {
 for(int j = 0 ; j < height * 2 ; j += 500) {
 drawShape01(i, j) ;
 }
 }
for(int i = 0 ; i < width * 2 ; i += 500) {
 for(int j = 250 ; j < height * 2 ; j += 500) {
 drawShape01(i, j) ;
 }
 } 
 
}
// ---------------------------------------------------------------
void drawCircle(int x, int y) {
 noFill() ;
 stroke(montella, 200) ;
 strokeWeight(2) ;
 ellipse(x, y, w, w) ;
}
//-----------------------------------
void drawShape01(int x, int y) {
 noFill() ;
 stroke(montella, 200) ;
 strokeWeight(2) ;
 fill(manilla, 255) ;
 ellipse(x, y, w/2, w/2) ; 
 fill(jasmine, 250) ;
 stroke(montella, 200) ;
 strokeWeight(2) ;
 int ycircle = (w/6) ;
 int mcircle = (w/10) ;
 ellipse(x, y - ycircle, ycircle, ycircle) ;
 ellipse(x + ycircle, y, ycircle, ycircle) ;
 ellipse(x, y + ycircle, ycircle, ycircle) ;
 ellipse(x - ycircle, y, ycircle, ycircle) ;
 // center
 fill(gbrown, 200) ;
 noStroke() ;
 ellipse(x, y, mcircle, mcircle) ;
}
//---------------------------------
void drawGuides() {
 stroke(0, 50) ;
 strokeWeight(1) ;
 // across
 line(250, 0, 250, 1000) ;
 line(500, 0, 500, 1000) ;
 line(750, 0, 750, 1000) ;
 // down
 line(0, 250, 1000, 250) ;
 line(0, 500, 1000, 500) ;
 line(0, 750, 1000, 750) ;
 // reset stroke
 stroke(0) ;
 strokeWeight(1) ;
}

A Seventies Mid-Century Wallpaper

The 1970s was like the 1960s only more so; that is it embodied the excitement and stimulation of the 1960s but took it to even greater extremes.

For the ordinary householder this meant a good variety of choice in patterns and colours for wallcoverings. The pattern today is a simple one but one which has an unusual look at the scale shown. This was a particular feature of 1970s wallpaper where great care was taken to give the maximum impact that the pattern could produce.

Once again the colouring follows the British Standard although the setting is a different one. This is a new version of an old room which began life as the dining room of the 1960s house.

You can also see larger versions of this and our other work on our Flickr page which is here.

PImage bg ;
color brass ; // stroke
color jonquil ;
color jasmine ;
color canary ;
color pred ;
color mbgreen ;
color montella ;

void setup() {
 size(1000, 1000) ;
 // background(255) ;
 bg = loadImage("055.jpg") ; // jasmine
 image(bg, 0, 0) ;
 drawGuides() ;
 
 // colors
 brass = color(#DBA20D) ;
 jonquil = color(#E8DFA0) ;
 jasmine = color(#F0DA5E) ;
 canary = color(#EFC400) ;
 pred = color(#C8361E) ; // poppy red
 mbgreen = color(#17472A) ; // mid Brunswicj green
 montella = color(#464130) ; 


 // rounds
 fill(brass, 175) ;
 stroke(montella, 150) ;
 strokeWeight(12) ;
 int rSize = 600 ;
 ellipse(500, 0, rSize, rSize) ;
 ellipse(500, 1000, rSize, rSize) ;
 ellipse(0, 500, rSize, rSize) ;
 ellipse(1000, 500, rSize, rSize) ;
 
 
 // diamonds
 // big
 fill(jasmine, 100) ;
 stroke(brass, 250) ;
 strokeWeight(2) ;
 drawDiamond01(500, 100) ;
 // middle
 fill(jonquil, 100) ;
 stroke(brass, 250) ;
 strokeWeight(2) ;
 drawDiamond02(500, 200) ;
 // center
 fill(canary, 100) ;
 stroke(brass, 250) ;
 strokeWeight(2) ;
 drawDiamond03(500, 300) ;
 // carry over
 fill(jasmine, 150) ;
 stroke(brass, 250) ;
 strokeWeight(2) ;
 drawDiamond04(1000, 400) ; // right
 drawDiamond04(0, 400) ; // left
 drawDiamond04(500, -100) ; // top
 drawDiamond04(500, 900) ; // bottom
 
 
}
//----------------------------------------------------------------

void drawDiamond01(int x, int y) {
 beginShape() ;
 vertex(x, y) ;
 vertex(x - 400, y + 400) ;
 vertex(x, y + 800) ;
 vertex( x + 400, y + 400) ;
 endShape(CLOSE) ;
}

void drawDiamond02(int x, int y) {
 beginShape() ;
 vertex(x, y) ;
 vertex(x - 300, y + 300) ;
 vertex(x, y + 600) ;
 vertex( x + 300, y + 300) ;
 endShape(CLOSE) ;
} 
 
void drawDiamond03(int x, int y) {
 beginShape() ;
 vertex(x, y) ;
 vertex(x - 200, y + 200) ;
 vertex(x, y + 400) ;
 vertex( x + 200, y + 200) ;
 endShape(CLOSE) ;
} 

void drawDiamond04(int x, int y) {
 beginShape() ;
 vertex(x, y) ;
 vertex(x - 100, y + 100) ;
 vertex(x, y + 200) ;
 vertex( x + 100, y + 100) ;
 endShape(CLOSE) ;
} 
//----------------------
void drawGuides() {
 stroke(0, 50) ;
 strokeWeight(1) ;
 // across
 line(250, 0, 250, 1000) ;
 line(500, 0, 500, 1000) ;
 line(750, 0, 750, 1000) ;
 // down
 line(0, 250, 1000, 250) ;
 line(0, 500, 1000, 500) ;
 line(0, 750, 1000, 750) ;
 // reset stroke
 stroke(0) ;
 strokeWeight(1) ;
}

A Flowery Mid-Century Living Room Wallpaper

If the 1960s was popularised by one thing then that things would have to be the stylised flower and in particular when used with the colour yellow.

This wallpaper was made in code using Processing and I have tried to tidy my scrappy code and remove all the unused colours (I hope) to make it more readable. The code is reproduced below if it helps anyone; to make it simpler for this pattern I have not used a background bitmap and so it should work as it is.

The stylised flowers in the circle are very 1960s and the finished pattern absolutely called for the walls of my 1960s living room set. After some experimentation with the scale I have to say that I am pleased with the result. Mid-century decorators would almost certainly have used this paper on all the walls but I felt that by doing that it made the image looks far too busy and so I have just used one wall and kept the wall by the window painted. This also has the effect of showcasing the pattern better on the remaining wall.

You can also see larger versions of this and our other work on our Flickr page which is here.

color canary ;
 color popRed ;
 color montella ;
void setup() {
 size(1000, 1000) ;
 background(50) ;
 canary = color(#EFC400) ;
 popRed = color(#C8361E) ; // Poppy red
 montella = color(#464130) ;
// drawGuides() ;
// flowers
 noStroke() ;
 for(int i = 0 ; i < width ; i += 500) {
 for(int j = 0 ; j < 1250 ; j += 500) {
 noStroke() ;
 fill(canary) ;
 drawFlower01(i, j) ;
 drawFlower01(i + 500, j) ;
 drawFlower01(i + 500, j) ;
 }
 }
for(int i = 250 ; i < width ; i += 500) {
 for(int j = 250 ; j < height ; j += 500) {
 noStroke() ;
drawFlower01(i, j) ;
 drawFlower01(i + 500, j) ;
 }
 }
//------------------------------------
// circles
 for(int i = 0 ; i < 1250 ; i += 500) {
 for(int j = 250 ; j < 1250 ; j += 500) {
 stroke(montella, 250) ;
 strokeWeight(4) ;
 fill(popRed) ;
 int circle = 150 ;
 ellipse(i, j, circle, circle) ;
 ellipse(i + 500, j, circle, circle) ;
 }
 }
for(int i = 250 ; i < 1250 ; i += 500) {
 for(int j = 0 ; j < 1250 ; j += 500) {
 stroke(montella, 250) ;
 strokeWeight(4) ;
 fill(popRed) ;
 int circle = 150 ;
 ellipse(i, j, circle, circle) ;
 ellipse(i + 500, j, circle, circle) ;
 ellipse(i + 1000, j, circle, circle) ;
 }
 }
}
//-------------------------------------------------------------------
void drawFlower01(int x, int y) {
 pushMatrix() ;
 translate(x, y) ;
 int w = 70 ; // flower width
 int h = 300 ; // flower height
 int c = 80 ; // flower center
 fill(canary) ;
 noStroke() ;
 ellipse(0, 0, w, h) ;
 rotate(radians(45)) ;
 ellipse(0, 0, w, h) ;
 rotate(radians(45)) ;
 ellipse(0, 0, w, h) ;
 rotate(radians(45)) ;
 ellipse(0, 0, w, h) ;
 rotate(radians(45)) ;
 ellipse(0, 0, w, h) ;
 // center --------------
 stroke(0) ;
 strokeWeight(2) ;
 fill(montella) ;
 ellipse(0, 0, c, c) ;
 popMatrix() ;
 }
// guides -----------------------------------
 void drawGuides() {
 stroke(0, 50) ;
 strokeWeight(1) ;
 // across
 line(250, 0, 250, 1000) ;
 line(500, 0, 500, 1000) ;
 line(750, 0, 750, 1000) ;
 // down
 line(0, 250, 1000, 250) ;
 line(0, 500, 1000, 500) ;
 line(0, 750, 1000, 750) ;
 // reset stroke
 stroke(0) ;
 strokeWeight(1) ;
 }

Late ’60s Wallpaper

Having messed about somewhat with the styles and times for the 1960s mid-century room I thought I ought to now show you a very 1960s paper.

To modern eyes this paper will look rather intrusive – and it is – but it is also very much the sort of paper that was in vogue towards the end of the 1960s decade. Designed to have a slight texture, the wallpaper really does catch the eye in this area of the room leaving you to imagine what the whole room would have looked like if you were to walk in from the main entrance.

Once again, this wall design was created in code with Processing using a very simple repeated motif and, of course, colours that are from the mid-century palette. I have included my scappy code at the end if it helps anyone although note that several of the colours are not used.

You can see larger versions of this and our other work on our Flickr page which is here.

PImage bg ;
 color parakeet ;
 color congoBrown ;
 color reefRed ;
 color canary ;
 color parisGreen ;
void setup() {
 size(1000, 1000) ;
 bg = loadImage("030.jpg") ;
 image(bg, 0, 0) ;
 // background(255) ;
 parakeet = color(#ACAD15) ;
 congoBrown = color(#574736) ;
 reefRed = color(#E07A67) ;
 canary = color(#EFC400) ;
 parisGreen = color(#008C50) ;
noFill() ;
 stroke(canary, 250) ;
 strokeWeight(2) ;
for(int i = 0 ; i < width ; i += 125) {
 for(int j = 0 ; j < height ; j += 125) {
 rect(i, j, 125, 125) ;
 }
 }
for(int i = 0 ; i < width ; i += 250) {
 for(int j = 0 ; j < height ; j += 125) {
 stroke(congoBrown, 200) ;
 strokeWeight(random(16, 19)) ;
 line(i, j, i + 125, j + 125) ;
 }
 }
for(int i = 125 ; i < width ; i += 250) {
 for(int j = 0 ; j < height ; j += 125) {
 stroke(parisGreen, 100) ;
 strokeWeight(random(10, 16)) ;
 line(i + 125, j, i, j + 125) ;
 }
 }
}

Mid-Century Wallpaper With Processing

One thing I have wanted to do ever since I started using Processing for the second time is to make some realistic mid-century wallpaper since this is what 20th century 3D was designed to do.

Those who have looked at earlier posts will realise that I have used the 1960s set inspired by an old television series to showcase this wallcovering. Technically, of course, the room depicts the mid-1960s although the wallpaper tries to create the impression of a 1950s design. No matter, wallpaper designs in those days tended to last from one decade into the next and if the wallpaper was thought saleable it would be kept on the book. I have tried to create the look of early 1950s design through the use of shape and form and also by using realistic mid-century colours.

Above is a small picture of the room and a swatch of pattern, but you can see larger versions of this, along with a detailed view, and our other work on our Flickr page which is here.

Processing Font Fun

We had dreary, miserable, wet weather this weekend and so I took the opportunity to have some font fun with Processing.

The image above shows my mid-century bedroom scene with a font inspired wallpaper. The background is mid-century off-white and the font is Sitka Heading, a Microsoft font created by Matthew Carter, and just the capital letter “T”.

Using this as a wallpaper gives it a look almost of anaglypta, a wall covering that was very popular mid-century, and particularly in the 1960s. Anaglypta wallpaper was a textured wallpaper, usually with swirls or random type patterns, however more structured patterning was also available. As a 3D texture this pattern, I think, looks extremely good on the walls and has a simulated texture that you could almost touch if you could walk into the room.

You can also see larger versions of this along with two other font styles and our other work on our Flickr page which is here.

// complete pattern of Ts
 PFont sitkaH ;
void setup() {
 size(1000, 1000) ;
 background(241, 230, 204) ; // off white
stroke(0, 50) ;
 strokeWeight(1) ;
// ---------------------------------------------------------
sitkaH = createFont("Sitka Heading", 200) ;
textFont(sitkaH) ;
fill(0) ;
for(int i = -7 ; i < width ; i += 100) {
 for(int j = 130 ; j < height ; j += 140) {
 text("T", i, j) ;
 }
 }
 }

A Useful Mid-Century Check

sketch_23_02_3d_800

One thing I have been trying to do is to make realistic looking check patterns primarily as textures for furniture and general furnishings in a 3D program

The big problem is not in making the check pattern, this is usually quite easy, but it is in making the resulting pattern look as though it is a realistic texture for use on 3D surfaces. Usually the end result looks as though it is 2D masquerading as 3D – which of course it is. Even with the use of a drawing program it is not always easy to create textures with a realistic look to them.

With processing, however, it is far easier to make the image look like a texture and hopefully this is what the illustration above and the images on our Flickr page look like. The order to create this image, the bands are made from closely spaced lines which give the appearance of texture. Combined with a background image created in Filter Forge which resembles material, this gives what I think is a quite realistic check for use as a furnishing pattern.

On our Flickr page you can see larger images but also the same pattern in a different color along with some swatches.

If it helps anyone, the code is shown below:

void setup() {
 size(1000, 1000) ;
 PImage bg ;
 bg = loadImage("068.jpg") ; // mable green
 image(bg, 0, 0) ;
 olive = color(#6D5D2F) ;
 stroke(olive, 255) ;
 strokeWeight(1) ;
 for(int i = 0 ; i < 500 ; i+= 2) {
 line(0, 250 + i, 1000, 250 + i) ;
 }
for(int i = 0 ; i < 500 ; i+= 2) {
 line(250 + i, 0, 250 + i, 1000) ;
 }
// perimeter lines acrodss
 chocolate = color(#352522) ;
 strokeWeight(10) ;
 stroke(chocolate, 200) ;
 line(0, 244, 1000, 244) ;
 line(0, 754, 1000, 754) ;
// down
 line(244, 0, 244, 1000) ;
 line(754, 0, 754, 1000) ;
 }