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) ;
 }

Unusual Mid-Century Kitchen Wallpaper

One of the nice things about the mid-century was the amount of experimentation that went on to produce and refine different designs and patterns.

I am still having problems with my elbow which prevents me from drawing although it does not, thankfully, prevent me from using the computer and so, with the advent of Filter Forge 5, I have been experimenting again with the filters.

This pattern was made using the Colourful flakes filter byCTextures and was designed as wallpaper for use in the kitchen. The set used is my 1950s kitchen set and the paper is shown in both light and dark styles to show the difference between the two.

During the mid-century period in the UK there were a lot of more unusual styles that appeared and I feel that this, together with its mid-century colouring, would have fitted in well. It is a busy paper with plenty going on which I think looks well in a kitchen designed very much for work.

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

A Detailed Mid-Century Style Furnishing Fabric

There are two things that we like at 20th Century 3D, one is mid-century inspired designs and the other is small repeats.

This furnishing design is both inspired by the fabrics produced in the 1950s and 1960s and also has the advantage of being a small repeat. Like all small repeats, the pattern itself is a very simple one where the effect as a furnishing fabric is quite subtle. At close quarters, that is when you are sitting on, or about to sit on, the furniture you see the whole of the pattern. From a distance, however, the pattern can look quite different.

On our Flickr page, which is here, you can see larger versions of the illustrations above together with a detailed picture. Although I originally intended the pattern to be used at a smaller scale, I decided that, at the scale shown, it seemed to look its best.

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.