File:Full octahedral group elements in truncated cuboctahedron; JF.png

Original file ‎(3,904 × 3,852 pixels, file size: 686 KB, MIME type: image/png)

This is a file from the Wikimedia Commons. The description on its description page there is shown below.

Commons is a freely licensed media file repository. You can help.

Summary

Description

Elements of the full octahedral group as permutations of identified with vertices of the truncated cuboctahedron

The neutral element is the light JF on the left. The light vertices are its 24 rotations. The dark ones are reflections.

This image was created with POV-Ray.

Date

25 February 2018

Source

Own work

Author

Watchduck
You can name the author as "T. Piesk", "Tilman Piesk" or "Watchduck".

Licensing

I, the copyright holder of this work, hereby publish it under the following licenses:

Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license is included in the section entitled GNU Free Documentation License.

This file is licensed under the Creative Commons Attribution 4.0 International license.

You are free:

to share – to copy, distribute and transmit the work
to remix – to adapt the work

Under the following conditions:

attribution – You must give appropriate credit, provide a link to the license, and indicate if changes were made. You may do so in any reasonable manner, but not in any way that suggests the licensor endorses you or your use.

You may select the license of your choice.

POV-Ray source

#version 3.6;
global_settings { assumed_gamma 1.0 }
#default{ finish{ ambient 0.1 diffuse 0.9 conserve_energy}}

#include "colors.inc"
#include "math.inc"
#include "textures.inc"


///////////////////////////// camera and light

#declare Camera_Position = <13.2, 10.5, -45>;
camera{
    location Camera_Position
    right    x*image_width/image_height
    angle    10.45
    look_at  <0, 0, 0>
}

light_source{ <-400, 500, -300> color White*0.9 shadowless}
light_source{ <400, 200, 100> color White*0.4 shadowless}
light_source{ Camera_Position  color rgb<0.9,0.9,1>*0.2 shadowless}
sky_sphere{ pigment{ White } }

///////////////////////////// sizes

#declare RadVert = .04;
#declare RadEdge = .01;

///////////////////////////// colors

#declare DarkColor = rgb<0.005, 0.004, 0.004>;  // edges of the JF compound

#declare Darkbrown = rgb<1,0.8,0.65>*.2;
#declare Lightbrown = rgb<1,0.8,0.65>*.5;

#declare EdgeColor = DarkColor;  // polyhedron
#declare FaceColor = rgbt <1, 1, 1, .7>;  // polyhedron


///////////////////////////////////////////////// macro to create the JF compound in the provided color

#macro letterJF(LightColor)

    #declare BigCyl = cylinder{ <0, 0, 0>, <0.9, 0, 0>, 1.5 }
    #declare SmallCyl = cylinder{ <-0.1, 0, 0>, <1, 0, 0>, 0.6 }
    #declare Ring = difference{
        object{BigCyl}
        object{SmallCyl}
    }
    #declare CutBox = box{
        <-10,-10,-10> <10,10,10>
        translate 10*y
    }
    #declare HalfRing = difference{
        object{Ring}
        object{CutBox}
    }
    #declare CutBox = object{
        CutBox
        rotate -45*x
        pigment{color DarkColor}
    }
    #declare LetterJTail = difference{
        object{HalfRing}
        object{CutBox}
    }


    #declare LetterStem = box{
        <0, 0, 0.6>
        <0.9, 2.4, 1.5>
    }


    #declare LetterFBar1 = box{
        <0, 1.5, 0.6>
        <-3, 2.4, 1.5>
    }
    #declare CutBox = box{
        <-10,-10,-10> <10,10,10>
        translate <-12.6, 0, 0>
        pigment{color DarkColor}
    }
    #declare LetterFBar1 = difference{
        object{LetterFBar1}
        CutBox
    }


    #declare LetterFBar2 = object{
        LetterFBar1
        translate <0, -1.5, 0>
    }
    #declare CutBox = object{
        CutBox
        translate <1.3, 0, 0>
    }
    #declare LetterFBar2 = difference{
        object{LetterFBar2}
        CutBox
    }


    #declare LetterJFSolid = union{
        object{LetterJTail}
        object{LetterStem}
        object{LetterFBar1}
        object{LetterFBar2}
        pigment{color LightColor}
    }


    ///////////////////////////// JF outline

    #declare R = 0.03;

    #declare PointFBar1a = <0.9, 2.4, 0.6>;
    #declare PointFBar1b = PointFBar1a + 0.9*z;
    #declare PointFBar1c = PointFBar1a - 3.5*x;
    #declare PointFBar1d = PointFBar1b - 3.5*x;

    #declare PointFBar2c = PointFBar1c - 0.9*y;
    #declare PointFBar2d = PointFBar2c + 0.9*z;
    #declare PointFBar2a = PointFBar2c + 2.6*x;
    #declare PointFBar2b = PointFBar2a + 0.9*z;

    #declare PointFBar3a = PointFBar2a - 0.6*y;
    #declare PointFBar3b = PointFBar3a + 0.9*z;
    #declare PointFBar3c = PointFBar3a - 1.3*x;
    #declare PointFBar3d = PointFBar3b - 1.3*x;

    #declare PointFBar4a = PointFBar3a - 0.9*y;
    #declare PointFBar4b = PointFBar4a + 0.9*z;
    #declare PointFBar4c = PointFBar4a - 1.3*x;
    #declare PointFBar4d = PointFBar4b - 1.3*x;

    #declare PointJFaceA = PointFBar4a + 0.9*x;
    #declare PointJFaceB = PointFBar4b + 0.9*x;

    #declare PointJEndA = <0.9, -sqrt(1.125), -sqrt(1.125)>;
    #declare PointJEndB = <0.9, -sqrt(0.18), -sqrt(0.18)>;
    #declare PointJEndC = PointJEndA - 0.9*x;
    #declare PointJEndD = PointJEndB - 0.9*x;


    #declare SmallTorus = object{
        torus {0.6, R}
        rotate 90*z
    }
    #declare BigTorus = object{
        torus {1.5, R}
        rotate 90*z
    }
    #declare Tori1 = union{
        object{SmallTorus}
        object{BigTorus}
    }
    #declare Tori2 = object{
        Tori1
        translate 0.9*x
    }
    #declare Tori = union{
        object{Tori1}
        object{Tori2}
    }

    #declare CutBox = box{
        <-10,-10,-10> <10,10,10>
        translate 10*y
    }
    #declare Tori = difference{
        object{Tori}
        object{CutBox}
    }
    #declare CutBox = object{
        CutBox
        rotate -45*x
    }
    #declare Tori = difference{
        object{Tori}
        object{CutBox}
    }


    #declare LetterJFOutlines = union{

        sphere{PointFBar1a, R}
        sphere{PointFBar1b, R}
        sphere{PointFBar1c, R}
        sphere{PointFBar1d, R}

        sphere{PointFBar2a, R}
        sphere{PointFBar2b, R}
        sphere{PointFBar2c, R}
        sphere{PointFBar2d, R}

        sphere{PointFBar3a, R}
        sphere{PointFBar3b, R}
        sphere{PointFBar3c, R}
        sphere{PointFBar3d, R}

        sphere{PointFBar4a, R}
        sphere{PointFBar4b, R}
        sphere{PointFBar4c, R}
        sphere{PointFBar4d, R}

        sphere{PointJEndA, R}
        sphere{PointJEndB, R}
        sphere{PointJEndC, R}
        sphere{PointJEndD, R}

        cylinder{PointFBar1a, PointFBar1b, R}
        cylinder{PointFBar1b, PointFBar1d, R}
        cylinder{PointFBar1d, PointFBar1c, R}
        cylinder{PointFBar1c, PointFBar1a, R}

        cylinder{PointFBar2a, PointFBar2b, R}
        cylinder{PointFBar2b, PointFBar2d, R}
        cylinder{PointFBar2d, PointFBar2c, R}
        cylinder{PointFBar2c, PointFBar2a, R}

        cylinder{PointFBar3a, PointFBar3b, R}
        cylinder{PointFBar3b, PointFBar3d, R}
        cylinder{PointFBar3d, PointFBar3c, R}
        cylinder{PointFBar3c, PointFBar3a, R}

        cylinder{PointFBar4a, PointFBar4b, R}
        cylinder{PointFBar4b, PointFBar4d, R}
        cylinder{PointFBar4d, PointFBar4c, R}
        cylinder{PointFBar4c, PointFBar4a, R}

        cylinder{PointFBar1c, PointFBar2c, R}
        cylinder{PointFBar1d, PointFBar2d, R}

        cylinder{PointFBar2a, PointFBar3a, R}
        cylinder{PointFBar2b, PointFBar3b, R}

        cylinder{PointFBar3c, PointFBar4c, R}
        cylinder{PointFBar3d, PointFBar4d, R}

        cylinder{PointFBar1a, PointJFaceA, R}
        cylinder{PointFBar1b, PointJFaceB, R}

        cylinder{PointJEndA, PointJEndB, R}
        cylinder{PointJEndB, PointJEndD, R}
        cylinder{PointJEndD, PointJEndC, R}
        cylinder{PointJEndC, PointJEndA, R}

        object{Tori}

        pigment{color DarkColor}

    }

    ///////////////////////////// JF compound as result of the macro

    union{
        object{LetterJFSolid}
        object{LetterJFOutlines}
        translate <0.85, -0.45, -0.25>
        scale .17
        rotate 90*y
    }

#end


///////////////////////////////////////////////// vertices, edges and faces of the truncated cuboctahedron

#declare Factor = .9;

#declare Abs = array[3]{ (1)*Factor, (1 + sqrt(2))*Factor, (1 + 2*sqrt(2))*Factor, }

#declare P = array[48]{ <-Abs[2],-Abs[1],-Abs[0]>, <-Abs[2],-Abs[1],Abs[0]>, <-Abs[2],-Abs[0],-Abs[1]>, <-Abs[2],-Abs[0],Abs[1]>, <-Abs[2],Abs[0],-Abs[1]>, <-Abs[2],Abs[0],Abs[1]>, <-Abs[2],Abs[1],-Abs[0]>, <-Abs[2],Abs[1],Abs[0]>, <-Abs[1],-Abs[2],-Abs[0]>, <-Abs[1],-Abs[2],Abs[0]>, <-Abs[1],-Abs[0],-Abs[2]>, <-Abs[1],-Abs[0],Abs[2]>, <-Abs[1],Abs[0],-Abs[2]>, <-Abs[1],Abs[0],Abs[2]>, <-Abs[1],Abs[2],-Abs[0]>, <-Abs[1],Abs[2],Abs[0]>, <-Abs[0],-Abs[2],-Abs[1]>, <-Abs[0],-Abs[2],Abs[1]>, <-Abs[0],-Abs[1],-Abs[2]>, <-Abs[0],-Abs[1],Abs[2]>, <-Abs[0],Abs[1],-Abs[2]>, <-Abs[0],Abs[1],Abs[2]>, <-Abs[0],Abs[2],-Abs[1]>, <-Abs[0],Abs[2],Abs[1]>, <Abs[0],-Abs[2],-Abs[1]>, <Abs[0],-Abs[2],Abs[1]>, <Abs[0],-Abs[1],-Abs[2]>, <Abs[0],-Abs[1],Abs[2]>, <Abs[0],Abs[1],-Abs[2]>, <Abs[0],Abs[1],Abs[2]>, <Abs[0],Abs[2],-Abs[1]>, <Abs[0],Abs[2],Abs[1]>, <Abs[1],-Abs[2],-Abs[0]>, <Abs[1],-Abs[2],Abs[0]>, <Abs[1],-Abs[0],-Abs[2]>, <Abs[1],-Abs[0],Abs[2]>, <Abs[1],Abs[0],-Abs[2]>, <Abs[1],Abs[0],Abs[2]>, <Abs[1],Abs[2],-Abs[0]>, <Abs[1],Abs[2],Abs[0]>, <Abs[2],-Abs[1],-Abs[0]>, <Abs[2],-Abs[1],Abs[0]>, <Abs[2],-Abs[0],-Abs[1]>, <Abs[2],-Abs[0],Abs[1]>, <Abs[2],Abs[0],-Abs[1]>, <Abs[2],Abs[0],Abs[1]>, <Abs[2],Abs[1],-Abs[0]>, <Abs[2],Abs[1],Abs[0]>, }

#declare DarkbrownVertices = array[24]{0, 3, 4, 7, 9, 10, 13, 14, 16, 19, 20, 23, 25, 26, 29, 30, 32, 35, 36, 39, 41, 42, 45, 46};

#declare LightbrownVertices = array[24]{1, 2, 5, 6, 8, 11, 12, 15, 17, 18, 21, 22, 24, 27, 28, 31, 33, 34, 37, 38, 40, 43, 44, 47};

#declare Edges = array[72]{array[2]{16, 24}, array[2]{43, 45}, array[2]{25, 33}, array[2]{46, 47}, array[2]{20, 28}, array[2]{11, 13}, array[2]{33, 41}, array[2]{18, 26}, array[2]{44, 46}, array[2]{5, 13}, array[2]{36, 44}, array[2]{11, 19}, array[2]{7, 15}, array[2]{2, 10}, array[2]{13, 21}, array[2]{34, 42}, array[2]{6, 14}, array[2]{10, 12}, array[2]{3, 11}, array[2]{9, 17}, array[2]{19, 27}, array[2]{35, 37}, array[2]{31, 39}, array[2]{40, 41}, array[2]{42, 44}, array[2]{29, 31}, array[2]{1, 3}, array[2]{25, 27}, array[2]{29, 37}, array[2]{5, 7}, array[2]{21, 29}, array[2]{45, 47}, array[2]{34, 36}, array[2]{24, 26}, array[2]{38, 39}, array[2]{23, 31}, array[2]{30, 38}, array[2]{12, 20}, array[2]{16, 18}, array[2]{8, 16}, array[2]{2, 4}, array[2]{21, 23}, array[2]{35, 43}, array[2]{28, 30}, array[2]{6, 7}, array[2]{37, 45}, array[2]{32, 40}, array[2]{41, 43}, array[2]{40, 42}, array[2]{14, 15}, array[2]{17, 19}, array[2]{24, 32}, array[2]{39, 47}, array[2]{4, 6}, array[2]{14, 22}, array[2]{26, 34}, array[2]{27, 35}, array[2]{28, 36}, array[2]{3, 5}, array[2]{0, 8}, array[2]{4, 12}, array[2]{10, 18}, array[2]{1, 9}, array[2]{15, 23}, array[2]{8, 9}, array[2]{22, 30}, array[2]{38, 46}, array[2]{0, 2}, array[2]{32, 33}, array[2]{20, 22}, array[2]{17, 25}, array[2]{0, 1}};

#declare Faces = array[26]{array[7]{P[9], P[17], P[19], P[11], P[3], P[1], P[9]}, array[9]{P[33], P[32], P[24], P[16], P[8], P[9], P[17], P[25], P[33]}, array[9]{P[43], P[41], P[40], P[42], P[44], P[46], P[47], P[45], P[43]}, array[9]{P[30], P[38], P[39], P[31], P[23], P[15], P[14], P[22], P[30]}, array[7]{P[5], P[13], P[21], P[23], P[15], P[7], P[5]}, array[5]{P[2], P[4], P[12], P[10], P[2]}, array[7]{P[31], P[29], P[37], P[45], P[47], P[39], P[31]}, array[9]{P[36], P[34], P[26], P[18], P[10], P[12], P[20], P[28], P[36]}, array[7]{P[18], P[16], P[8], P[0], P[2], P[10], P[18]}, array[7]{P[34], P[26], P[24], P[32], P[40], P[42], P[34]}, array[7]{P[28], P[30], P[38], P[46], P[44], P[36], P[28]}, array[7]{P[27], P[35], P[43], P[41], P[33], P[25], P[27]}, array[7]{P[4], P[6], P[14], P[22], P[20], P[12], P[4]}, array[5]{P[38], P[39], P[47], P[46], P[38]}, array[5]{P[0], P[8], P[9], P[1], P[0]}, array[9]{P[7], P[5], P[3], P[1], P[0], P[2], P[4], P[6], P[7]}, array[9]{P[35], P[37], P[29], P[21], P[13], P[11], P[19], P[27], P[35]}, array[5]{P[7], P[15], P[14], P[6], P[7]}, array[5]{P[32], P[33], P[41], P[40], P[32]}, array[5]{P[18], P[16], P[24], P[26], P[18]}, array[5]{P[5], P[13], P[11], P[3], P[5]}, array[5]{P[35], P[43], P[45], P[37], P[35]}, array[5]{P[34], P[36], P[44], P[42], P[34]}, array[5]{P[22], P[30], P[28], P[20], P[22]}, array[5]{P[21], P[23], P[31], P[29], P[21]}, array[5]{P[19], P[17], P[25], P[27], P[19]}};


union{

    union{
        #for( Index, 0, dimension_size(DarkbrownVertices, 1) - 1 )
            sphere{ P[DarkbrownVertices[Index]], RadVert }
        #end
        pigment{ color Darkbrown }
    }
    union{
        #for( Index, 0, dimension_size(LightbrownVertices, 1) - 1 )
            sphere{ P[LightbrownVertices[Index]], RadVert }
        #end
        pigment{ color Lightbrown }
    }

    union{
        #for( Index, 0, dimension_size(Edges, 1) - 1 )
            #local EdgeArray = Edges[Index];
            cylinder{ P[EdgeArray[0]], P[EdgeArray[1]], RadEdge }
        #end
        pigment{ color EdgeColor }
    }

    union{
        #for( Index, 0, dimension_size(Faces, 1) - 1 )
            #local FaceArray = Faces[Index];
            #local LenOfFaceArray = dimension_size(FaceArray, 1);
            polygon{ LenOfFaceArray,
                #for(VertexIndexInFace, 0, LenOfFaceArray-1)
                    FaceArray[VertexIndexInFace]
                #end
            }
        #end
        pigment{ color FaceColor }
    }

    scale .92
}


///////////////////////////////////////////////// ingredients to create the 24 rotations (light vertices)

// All 48 permutations of the full octahedral group are products of the ones in the two arrays below.
// The words 'row' and 'column' come from a context of left action, where r*c means c is executed first.
// Povray uses right action though, so to execute c first one has to write `transform{ c r }`.

#declare RowTransformations = array[8]{
    transform{ },
    transform{ scale -x },
    transform{ scale -z },
    transform{ rotate 180*y },
    transform{ scale -y },
    transform{ rotate 180*z },
    transform{ rotate 180*x },
    transform{ scale <-1, -1, -1> }
}

#declare ColTransformations = array[6]{
    transform{ },
    transform{ scale -z rotate -90*y },
    transform{ scale -y rotate -90*x },
    transform{ rotate 90*x rotate 90*z },
    transform{ rotate -90*z rotate -90*x },
    transform{ scale -x rotate -90*z }
}

// The following array contains the 24 pairs (r, c) for which r*c (or `transform{ c r }`) is an even permutation.

#declare RowCol = array[24]{
    array[2]{0, 0}, array[2]{0, 3}, array[2]{0, 4}, 
    array[2]{1, 1}, array[2]{1, 2}, array[2]{1, 5}, 
    array[2]{2, 1}, array[2]{2, 2}, array[2]{2, 5}, 
    array[2]{3, 0}, array[2]{3, 3}, array[2]{3, 4}, 
    array[2]{4, 1}, array[2]{4, 2}, array[2]{4, 5}, 
    array[2]{5, 0}, array[2]{5, 3}, array[2]{5, 4}, 
    array[2]{6, 0}, array[2]{6, 3}, array[2]{6, 4}, 
    array[2]{7, 1}, array[2]{7, 2}, array[2]{7, 5}
}


///////////////////////////////////////////////// permute and place the JF compounds

// even permutations (light)

#declare LetterJF = object{ 
    letterJF(Lightbrown)
    translate P[2]
}

#for( Index, 0, 23 )
    #local Row = RowCol[Index][0];
    #local Col = RowCol[Index][1];
    #local RowTrans = RowTransformations[Row];
    #local ColTrans = ColTransformations[Col];
    object{
        LetterJF
        transform{ ColTrans RowTrans }
    }
#end

// odd permutations (dark) as reflection of the even ones

#declare LetterJF = object{ 
    letterJF(Darkbrown)
    translate P[2]
}

union{
    #for( Index, 0, 23 )
        #local Row = RowCol[Index][0];
        #local Col = RowCol[Index][1];
        #local RowTrans = RowTransformations[Row];
        #local ColTrans = ColTransformations[Col];
        object{
            LetterJF
            transform{ ColTrans RowTrans }
        }
    #end
    scale -x
}

File history

Click on a date/time to view the file as it appeared at that time.

	Date/Time	Thumbnail	Dimensions	User	Comment
current	13:46, 25 February 2018		3,904 × 3,852 (686 KB)	Watchduck

File usage

The following page uses this file:

Full octahedral group

Global file usage

The following other wikis use this file:

Usage on en.wikipedia.org
- Truncated cuboctahedron
Usage on ro.wikipedia.org
- Cuboctaedru trunchiat

Metadata

This file contains additional information, probably added from the digital camera or scanner used to create or digitize it.

If the file has been modified from its original state, some details may not fully reflect the modified file.

PNG file comment	Render Date: 2018-02-25 03:46:56Z Platform: x86_64-pc-linux-gnu Compiler: g++ 5.2.1
Horizontal resolution	28.35 dpc
Vertical resolution	28.35 dpc
File change date and time	12:07, 25 February 2018

File:Full octahedral group elements in truncated cuboctahedron; JF.png

Summary

Licensing

POV-Ray source

Captions

Items portrayed in this file

depicts

creator

some value

copyright status

copyrighted

copyright license

GNU Free Documentation License, version 1.2 or later

Creative Commons Attribution 4.0 International

source of file

original creation by uploader

inception

25 February 2018

MIME type

image/png

File history

File usage

Global file usage

Metadata