renamed modules

1 files changed, 0 insertions, 183 deletions

diff --git a/lib/Pb/Gradient.py b/lib/Pb/Gradient.py
deleted file mode 100755
index 340ce62..0000000
--- a/lib/Pb/Gradient.py
+++ /dev/null
@@ -1,183 +0,0 @@
-#!/usr/bin/python2.7

-import re

-import time

-from subprocess import call 

-import simplejson as json

-import sys

-import os

-import sha

-from config import *

-from Pb import Pb

-

-_default_color_1 = "white"

-_default_color_2 = "black"

-

-_default_bevel_percent = "12";

-

-_halftone_values = {

-    "checkeredfade": "h6x6a",

-    "etchedtransition": "o8x8",

-    "bendaydots": "h16x16o",

-    "smallerdots1": "h8x8o",

-    "smallerdots2": "c7x7w",

-    "flatstripes": "o2x2",

-}

-

-class PbGradient(Pb):

-    example_params = {

-      "width" : "200",

-      "color1" : "#ffdead",

-      "color2" : "blue",

-      "stripes" : "true",

-      "stripenumber" : "20",

-      "gradienttype" : "radial",

-      "stripeintensity" : "20",

-      "halftone" : "checkeredfade",

-      "percentbeveled" : "30",

-      "flip" : "true",

-      "bevel" : "flatinner",

-      "rotate" : "20",

-      "height" : "200",

-      "filetype" : "jpg",

-      "username" : "whatever"

-    }

-    def __init__(self, **kwargs):

-        super(PbGradient,self).__init__(**kwargs);

-        _definitions = {

-          'width': { 'type':'int', 'default': DEFAULT_WIDTH },

-          'height': { 'type':'int', 'default' : DEFAULT_HEIGHT },

-          'color1': { 'type':'color', 'default': _default_color_1 },

-          'color2': { 'type':'color', 'default': _default_color_2 },

-          'stripes': { 'type':'bool' },

-          'stripenumber': { 'type':'int', 'default': 0 },

-          'stripeintensity': { 'type':'int', 'default': 0 },

-          'blurriness': { 'type':'int', 'default': 0 },

-          'contrast': { 'type':'int', 'default': 100 },

-          'brightness': { 'type':'int', 'default': 100 },

-          'saturation': { 'type':'int', 'default': 100 },

-          'hue': { 'type':'int', 'default': 100 },

-          'halftone': { 'type':'enum', 'enum_values' : [

-            'checkeredfade', 'etchedtransition', 'bendaydots',

-            'smallerdots1', 'smallerdots2', 'flatstripes',

-          ] },

-          'bevel': { 'type':'enum', 'enum_values' : [

-            'flatout', 'flatinner', 'evenlyframed', 'biginner',

-            'bigouter', 'dramaticflatout', 'dramaticflatinner',

-          ] },

-          'percentbeveled': { 'type':'int', 'default': _default_bevel_percent },

-          'tilt': { 'type':'int' },

-          'rotate': { 'type':'int' },

-          'flip': { 'type':'bool' },

-          'flop': { 'type':'bool' },

-          'filetype': { 'type':'enum', 'enum_values' : OUTPUT_IMAGE_TYPES, 'default': DEFAULT_FINALFORMAT },

-          'gradienttype': { 'type':'enum', 'enum_values' : [

-            'default', 'canvas', 'radial',  'colorspace',  

-            'mirrored',  'plasmawash',  'gradientwash',  'noise'

-          ], 'default': 'default' },

-          'username': { 'type':'string' }

-        }

-        self.params.definitions_import(_definitions, kwargs, classname=self.__class__.__name__);

-

-        self.filename, self.filepath = self._filename_filepath_create()

-

-    def _filename_create(self, **kwargs):         

-        _base = "{}{}-{}_{}".format(

-           self.__class__.__name__, 

-           str(self.params.color1).replace('#','').replace('(','-').replace(')','-'),

-           str(self.params.color2).replace('#','').replace('(','-').replace(')','-'),

-           self._now,                                         

-        )

-        if self.params.username: _base += "_%s" % self.params.username

-        return _base + ".%s" % self.params.filetype

-

-

-    def _build_cmd(self):

-        cmd = [BIN_CONVERT]

-        cmd.extend([

-            '-size',

-            "{}x{}".format(self.params.width,self.params.height)

-        ])

-        

-        if self.params.rotate: cmd.extend(["-rotate", self.params.rotate])         

-        if self.params.tilt: cmd.extend(["-distort","SRT",self.params.tilt])

-        if self.params.flip == "true": cmd.append("-flip")

-        if self.params.flop == "true": cmd.append("-flop")

-        if self.params.contrast: cmd.extend(["-contrast-stretch", self.params.contrast])

-        _gradients = {

-            "default" : "gradient:{}-{}".format(self.params.color1, self.params.color2),

-            "canvas" : ["canvas:{}".format(self.params.color1)],

-            "radial" : [

-                "radial-gradient:{}-{}".format( self.params.color1, self.params.color2)

-                ],

-            "colorspace" : [

-                "-colorspace",

-                "Gray",

-                "plasma:{}-{}".format(self.params.color1, self.params.color2)

-            ],

-            "mirrored" : [

-                "plasma:{}-{}".format(self.params.color1, self.params.color2),

-                 "\(","+clone","-flop","\)",

-                 "append"

-            ],

-            "plasmawash" : [

-                "plasma:{}-{}".format(self.params.color1, self.params.color2),

-                "-set","colorspace","HSB"

-            ],

-            "gradientwash" : [

-                "gradient:{}-{}".format(self.params.color1, self.params.color2),

-                "-set","colorspace","HSB"

-            ],

-            "noise" : ["xc:","+noise","Random","-virtual-pixel","tile"]

-            }

-        cmd += _gradients[str(self.params.gradienttype)]

-            

-        if self.params.blurriness: 

-            cmd.extend(["-blur","0x{}".format(self.params.blurriness),"-auto-level"])

-        

-        if self.params.stripes == "true" and len(self.params.stripenumber):

-            cmd.extend(["-function","Sinusoid"])

-            if self.params.stripeintensity:  

-                cmd.append("{},{}".format(self.params.stripenumber,self.params.stripeintensity))

-            else:

-                cmd.append(self.params.stripenumber)

-        if str(self.params.halftone) in _halftone_values: 

-            cmd.extend([

-                "-ordered-dither", 

-                _halftone_values[str(self.params.halftone)]

-            ])

-        cmd += [ 

-            '-modulate', 

-            "{},{},{}".format(

-            self.params.brightness or "100",

-            self.params.saturation or "100",

-            self.params.hue or "100")

-        ]

-        cmd.append(self.filepath);

-        self._call_cmd(cmd)

-        if self.params.bevel: self._make_bevel()

-

-    def _get_bevelvalue(self):

-        w, h = map(int, (self.params.width, self.params.height))

-        if h >= w:

-            bevpercentval = str(int(self.params.percentbeveled)*0.005*int(h))

-        else:

-            bevpercentval = str(int(self.params.percentbeveled)*0.005*int(w))

-        return {

-            "flatout": ["-s",bevpercentval,"-m","outer"],

-            "flatinner": ["-s",bevpercentval,"-m","inner"],

-            "evenlyframed": ["-s ",bevpercentval,"-m", "split"],

-            "biginner": ["-s",bevpercentval,"-m","outer","-c","50","-b","red","-a","25"],

-            "bigouter": ["-s",bevpercentval,"-m","split","-c","50","-b","red","-a","25"],

-            "dramaticflatout": ["-s",bevpercentval,"-m","outer","-a","25","-b","blue"],

-            "dramaticflatinner": ["-s",bevpercentval,"-m","outer","-a","25","-b","blue"],

-        }[str(self.params.bevel)]

-

-    def _make_bevel(self):

-        cmd = [BEVELBORDER]

-        cmd += self._get_bevelvalue() 

-        cmd += [ self.filepath, self.filepath]

-        self._call_cmd(cmd)

-

-    def create(self):

-        self._build_cmd()

-        super(PbGradient, self).create()