mediaComp 0.0.1__py3-none-any.whl

mediaComp/__init__.py

@@ -0,0 +1,23 @@
+from .core import *
+from mediaComp.models.Config import ConfigManager
+
+__all__ = [
+    "setColorWrapAround", "getColorWrapAround", "pickAColor", "distance", "makeDarker", "makeLighter", "makeColor",
+    "setMediaFolder", "setTestMediaFolder", "getMediaFolder", 
+    "showMediaFolder", "getShortPath", "setLibFolder", "pickAFile", "pickAFolder",
+    "randomPixels", "pictureTool", "pixelsToPicture", "makePicture", "makeEmptyPicture", "getPixels", "getWidth", "getHeight", "show",
+    "repaint", "addLine", "addText", "addRect", "addRectFilled", "addOval", "addOvalFilled", "addArc", "addArcFilled", 
+    "getPixelAt", "setRed", "setGreen", "setBlue", "getRed", "getGreen", "getBlue", "getColor", "setColor", "getX", "getY", 
+    "writePictureTo", "setAllPixelsToAColor", "copyInto", "duplicatePicture", "cropPicture", "calculateNeededFiller",
+    "requestInteger", "requestNumber", "requestIntegerInRange", "requestString", "showWarning", "showInformation", "showError",
+    "playMovie", "writeQuicktime", "writeAVI", "makeMovie", "makeMovieFromInitialFile", "addFrameToMovie", "writeFramesToDirectory", 
+    "samplesToSound", "makeSound", "makeEmptySound", "makeEmptySoundBySeconds", "duplicateSound", "getSamples", "soundTool", 
+    "play", "blockingPlay", "stopPlaying", "playAtRate", "playAtRateDur", "playInRange", "blockingPlayInRange", "playAtRateInRange", 
+    "blockingPlayAtRateInRange", "getSamplingRate", "getSampleValueAt", "setSampleValueAt", "setSampleValue", 
+    "getSampleValue", "getSound", "getNumSamples", "getDuration", "writeSoundTo", "randomSamples", "getIndex", 
+    "playNote", "turn", "turnRight", "turnToFace", "turnLeft", "forward", "backward", "moveTo", "makeTurtle", "penUp", 
+    "penDown", "drop", "getXPos", "getYPos", "getHeading", "makeWorld", "getTurtleList", "blue", "red", 
+    "green", "gray", "darkGray", "lightGray", "yellow", "orange", "pink", "magenta", "cyan"
+]
+
+config = ConfigManager

mediaComp/core/__init__.py

@@ -0,0 +1,7 @@
+from .color import *
+from .utils import *
+from .image import *
+from .movie import *
+from .sound import *
+from .turtle import *
+from .world import *

mediaComp/core/color.py

@@ -0,0 +1,50 @@
+from ..models.PixelColor import Pixel, Color
+
+black = Color(0, 0, 0)
+white = Color(255, 255, 255)
+blue = Color(0, 0, 255)
+red = Color(255, 0, 0)
+green = Color(0, 255, 0)
+gray = Color(128, 128, 128)
+darkGray = Color(64, 64, 64)
+lightGray = Color(192, 192, 192)
+yellow = Color(255, 255, 0)
+orange = Color(255, 200, 0)
+pink = Color(255, 175, 175)
+magenta = Color(255, 0, 255)
+cyan = Color(0, 255, 255)
+
+def setColorWrapAround(setting):
+    Pixel.setWrapLevels(bool(setting))
+
+def getColorWrapAround():
+    return Pixel.getWrapLevels()
+
+def pickAColor():
+    return Color.pickAColor()
+
+def distance(c1, c2):
+    if not isinstance(c1, Color):
+        print("distance(c1,c2): First input is not a color")
+        raise ValueError
+    if not isinstance(c2, Color):
+        print("distance(c1,c2): Second input is not a color")
+        raise ValueError
+    return c1.distance(c2)
+
+def makeDarker(color):
+    if not isinstance(color, Color):
+        print("makeDarker(color): Input is not a color")
+        raise ValueError
+    return Color(color.makeDarker())
+
+def makeLighter(color):
+    if not isinstance(color, Color):
+        print("makeLighter(color): Input is not a color")
+        raise ValueError
+    return Color(color.makeLighter())
+
+
+def makeColor(red, green=None, blue=None):
+    return Color(red, green, blue)
+

mediaComp/core/image.py

@@ -0,0 +1,310 @@
+from ..models.Picture import Picture
+from ..models.PixelColor import Pixel, Color
+import os, random
+
+black = Color(0, 0, 0)
+white = Color(255, 255, 255)
+
+def randomPixels(somePic, number):
+    pixelList = []
+    pixels = getPixels(somePic)
+    for count in range(number):
+        pixelList.append(random.choice(pixels))
+    if(isinstance(pixelsToPicture(pixelList), Picture)):
+        pictureTool(pixelsToPicture(pixelList))
+
+def pictureTool(picture):
+    if isinstance(picture, Picture):
+        picture.pictureTool()
+    else: 
+        print("openPicture(picture): Input is not a picture.")
+        raise ValueError
+
+def pixelsToPicture(pixels, defaultColor=white, maxX=100, maxY=100):
+    maxX = max([getX(p) for p in pixels])
+    maxY = max([getY(p) for p in pixels])
+    newpic = makeEmptyPicture(maxX + 1, maxY + 1, defaultColor)
+    for pixel in pixels:
+        x = getX(pixel)
+        y = getY(pixel)
+        setColor(getPixelAt(newpic, x, y), getColor(pixel))
+    return newpic
+
+
+def makePicture(filename, defaultColor=white):
+    global mediaFolder
+    if not isinstance(filename, str):
+        return pixelsToPicture(filename, defaultColor=defaultColor)
+    if not os.path.isabs(filename):
+        filename = mediaFolder + filename
+    if not os.path.isfile(filename):
+        print("makePicture(filename): There is no file at " + filename)
+        raise ValueError
+    picture = Picture()
+    picture.loadOrFail(filename)
+    return picture
+
+
+def makeEmptyPicture(width, height, acolor=white):
+    if width > 10000 or height > 10000:
+        print("makeEmptyPicture(width, height[, acolor]): height and width must be less than 10000 each")
+        raise ValueError
+    if width <= 0 or height <= 0:
+        print("makeEmptyPicture(width, height[, acolor]): height and width must be greater than 0 each")
+        raise ValueError
+    picture = Picture(width, height, acolor)
+    return picture
+
+def getPixels(picture):
+    if not isinstance(picture, Picture):
+        print("getPixels(picture): Input is not a picture")
+        raise ValueError
+    return picture.getPixels()
+
+
+def getWidth(picture):
+    if not isinstance(picture, Picture):
+        print("getWidth(picture): Input is not a picture")
+        raise ValueError
+    return picture.getWidth()
+
+
+def getHeight(picture):
+    if not isinstance(picture, Picture):
+        print("getHeight(picture): Input is not a picture")
+        raise ValueError
+    return picture.getHeight()
+
+def show(picture, title=None):
+    if not isinstance(picture, Picture):
+        print("show(picture): Input is not a picture")
+        raise ValueError
+    picture.show()
+
+def repaint(picture):
+    if not isinstance(picture, Picture):
+        print("repaint(picture): Input is not a picture")
+        raise ValueError
+    picture.repaint()
+
+def addLine(picture, x1, y1, x2, y2, acolor=black):
+    if not isinstance(picture, Picture):
+        print("addLine(picture, x1, y1, x2, y2[, color]): First input is not a picture")
+        raise ValueError
+    if not isinstance(acolor, Color):
+        print("addLine(picture, x1, y1, x2, y2[, color]): Last input is not a color")
+        raise ValueError
+    picture.addLine(acolor, x1, y1, x2, y2)
+
+
+def addText(picture, x, y, string, acolor=black):
+    if not isinstance(picture, Picture):
+        print("addText(picture, x, y, string[, color]): First input is not a picture")
+        raise ValueError
+    if not isinstance(acolor, Color):
+        print("addText(picture, x, y, string[, color]): Last input is not a color")
+        raise ValueError
+    
+    picture.addText(acolor, x, y, string)
+
+
+def addRect(picture, x, y, w, h, acolor=black):
+    if not isinstance(picture, Picture):
+        print("addRect(picture, x, y, w, h[, color]): First input is not a picture")
+        raise ValueError
+    if not isinstance(acolor, Color):
+        print("addRect(picture, x, y, w, h[, color]): Last input is not a color")
+        raise ValueError
+    picture.addRect(acolor, x, y, w, h)
+
+
+def addRectFilled(picture, x, y, w, h, acolor=black):
+    if not isinstance(picture, Picture):
+        print("addRectFilled(picture, x, y, w, h[, color]): First input is not a picture")
+        raise ValueError
+    if not isinstance(acolor, Color):
+        print("addRectFilled(picture, x, y, w, h[, color]): Last input is not a color")
+        raise ValueError
+    picture.addRectFilled(acolor, x, y, w, h)
+
+
+def addOval(picture, x, y, w, h, acolor=black):
+    if not isinstance(picture, Picture):
+        print("addOval(picture, x, y, w, h[, color]): First input is not a picture")
+        raise ValueError
+    if not isinstance(acolor, Color):
+        print("addOval(picture, x, y, w, h[, color]): Last input is not a color")
+        raise ValueError
+    picture.addOval(acolor, x, y, w, h)
+
+
+def addOvalFilled(picture, x, y, w, h, acolor=black):
+    if not isinstance(picture, Picture):
+        print("addOvalFilled(picture, x, y, w, h[, color]): First input is not a picture")
+        raise ValueError
+    if not isinstance(acolor, Color):
+        print("addOvalFilled(picture, x, y, w, h[, color]): Last input is not a color")
+        raise ValueError
+    picture.addOvalFilled(acolor, x, y, w, h)
+
+
+def addArc(picture, x, y, w, h, start, angle, acolor=black):
+    if not isinstance(picture, Picture):
+        print("addArc(picture, x, y, w, h, start, angle[, color]): First input is not a picture")
+        raise ValueError
+    if not isinstance(acolor, Color):
+        print("addArc(picture, x, y, w, h, start, angle[, color]): Last input is not a color")
+        raise ValueError
+    picture.addArc(acolor, x, y, w, h, start, angle)
+
+
+def addArcFilled(picture, x, y, w, h, start, angle, acolor=black):
+    if not isinstance(picture, Picture):
+        print("addArcFilled(picture, x, y, w, h[, color]): First First input is not a picture")
+        raise ValueError
+    if not isinstance(acolor, Color):
+        print("addArcFilled(picture, x, y, w, h, start, angle[, color]): Last input is not a color")
+        raise ValueError
+    picture.addArcFilled(acolor, x, y, w, h, start, angle)
+
+def getPixelAt(picture, x, y):
+    if not isinstance(picture, Picture):
+        print("getPixel(picture,x,y): First input is not a picture")
+        raise ValueError
+    if (x < Picture._PictureIndexOffset) or (x > getWidth(picture) - 1 + Picture._PictureIndexOffset):
+        print("getPixel(picture,x,y): x (= {}) is less than {} or bigger than the width (= {})".format(x, Picture._PictureIndexOffset, getWidth(picture) - 1 + Picture._PictureIndexOffset))
+        raise ValueError
+    if (y < Picture._PictureIndexOffset) or (y > getHeight(picture) - 1 + Picture._PictureIndexOffset):
+        print("getPixel(picture,x,y): y (= {}) is less than {} or bigger than the height (= {})".format(y, Picture._PictureIndexOffset, getHeight(picture) - 1 + Picture._PictureIndexOffset))
+        raise ValueError
+
+    return picture.getPixel(x - Picture._PictureIndexOffset, y - Picture._PictureIndexOffset)
+
+
+def setRed(pixel, value):
+    value = Pixel.correctLevel(value)
+    if not isinstance(pixel, Pixel):
+        print("setRed(pixel,value): Input is not a pixel")
+        raise ValueError
+    pixel.setRed(value)
+
+
+def getRed(pixel):
+    if not isinstance(pixel, Pixel):
+        print("getRed(pixel): Input is not a pixel")
+        raise ValueError
+    return pixel.getRed()
+
+
+def setBlue(pixel, value):
+    value = Pixel.correctLevel(value)
+    if not isinstance(pixel, Pixel):
+        print("setBlue(pixel,value): Input is not a pixel")
+        raise ValueError
+    pixel.setBlue(value)
+
+
+def getBlue(pixel):
+    if not isinstance(pixel, Pixel):
+        print("getBlue(pixel): Input is not a pixel")
+        raise ValueError
+    return pixel.getBlue()
+
+
+def setGreen(pixel, value):
+    value = Pixel.correctLevel(value)
+    if not isinstance(pixel, Pixel):
+        print("setGreen(pixel,value): Input is not a pixel")
+        raise ValueError
+    pixel.setGreen(value)
+
+
+def getGreen(pixel):
+    if not isinstance(pixel, Pixel):
+        print("getGreen(pixel): Input is not a pixel")
+        raise ValueError
+    return pixel.getGreen()
+
+
+def getColor(pixel):
+    if not isinstance(pixel, Pixel):
+        print("getColor(pixel): Input is not a pixel")
+        raise ValueError
+    return Color(pixel.getColor())
+
+
+def setColor(pixel, color):
+    if not isinstance(pixel, Pixel):
+        print("setColor(pixel,color): First input is not a pixel")
+        raise ValueError
+    if not isinstance(color, Color):
+        print("setColor(pixel,color): Second input is not a color")
+        raise ValueError
+    pixel.setColor(color)
+
+def getX(pixel):
+    if not isinstance(pixel, Pixel):
+        print("getX(pixel): Input is not a pixel")
+        raise ValueError
+    return pixel.getX() + Picture._PictureIndexOffset
+
+
+def getY(pixel):
+    if not isinstance(pixel, Pixel):
+        print("getY(pixel): Input is not a pixel")
+        raise ValueError
+    return pixel.getY() + Picture._PictureIndexOffset
+
+def writePictureTo(picture, filename):
+    global mediaFolder
+    if not os.path.isabs(filename):
+        filename = mediaFolder + filename
+    if not isinstance(picture, Picture):
+        print("writePictureTo(picture,filename): First input is not a picture")
+        raise ValueError
+    picture.writeOrFail(filename)
+
+def setAllPixelsToAColor(picture, color):
+    if not isinstance(picture, Picture):
+        print("setAllPixelsToAColor(picture,color): First input is not a picture")
+        raise ValueError
+    if not isinstance(color, Color):
+        print("setAllPixelsToAColor(picture,color): Second input is not a color")
+        raise ValueError
+    picture.setAllPixelsToAColor(color)
+
+def copyInto(origPict, destPict, upperLeftX, upperLeftY):
+ if not isinstance(origPict, Picture):
+   print("copyInto(origPict, destPict, upperLeftX, upperLeftY): First parameter is not a picture")
+   raise ValueError
+ if not isinstance(destPict, Picture):
+   print("copyInto(origPict, destPict, upperLeftX, upperLeftY): Second parameter is not a picture")
+   raise ValueError
+ if upperLeftX < 0 or upperLeftX > getWidth(destPict):
+   print("copyInto(origPict, destPict, upperLeftX, upperLeftY): upperLeftX must be within the destPict")
+   raise ValueError
+ if upperLeftY < 0 or upperLeftY > getHeight(destPict):
+   print("copyInto(origPict, destPict, upperLeftX, upperLeftY): upperLeftY must be within the destPict")
+   raise ValueError
+ return origPict.copyInto(destPict, upperLeftX-1, upperLeftY-1)
+
+
+def duplicatePicture(picture):
+    """returns a copy of the picture"""
+    if not isinstance(picture, Picture):
+        print("duplicatePicture(picture): Input is not a picture")
+        raise ValueError
+    return Picture(picture)
+
+def cropPicture(picture, upperLeftX, upperLeftY, width, height):
+ if not isinstance(picture, Picture):
+   print("crop(picture, upperLeftX, upperLeftY, width, height): First parameter is not a picture")
+   raise ValueError
+ if upperLeftX < 1 or upperLeftX > getWidth(picture):
+   print("crop(picture, upperLeftX, upperLeftY, width, height): upperLeftX must be within the picture")
+   raise ValueError
+ if upperLeftY < 1 or upperLeftY > getHeight(picture):
+   print("crop(picture, upperLeftX, upperLeftY, width, height): upperLeftY must be within the picture")
+   raise ValueError
+ return picture.crop(upperLeftX-1, upperLeftY-1, width, height)
+

mediaComp/core/movie.py

@@ -0,0 +1,83 @@
+from ..models.Movie import Movie
+import os
+
+
+def playMovie(movie):
+    if isinstance(movie, Movie):
+        movie.play()
+    else:
+        print("playMovie( movie ): Input is not a Movie")
+        raise ValueError
+
+
+def writeQuicktime(movie, destPath, framesPerSec=16):
+    if not (isinstance(movie, Movie)):
+        print("writeQuicktime(movie, path[, framesPerSec]): First input is not a Movie")
+        raise ValueError
+    if framesPerSec <= 0:
+        print("writeQuicktime(movie, path[, framesPerSec]): Frame rate must be a positive number")
+        raise ValueError
+    movie.writeQuicktime(destPath, framesPerSec)
+
+
+def writeAVI(movie, destPath, framesPerSec=16):
+    if not (isinstance(movie, Movie)):
+        print("writeAVI(movie, path[, framesPerSec]): First input is not a Movie")
+        raise ValueError
+    if framesPerSec <= 0:
+        print("writeAVI(movie, path[, framesPerSec]): Frame rate must be a positive number")
+        raise ValueError
+    movie.writeAVI(destPath, framesPerSec)
+
+
+def makeMovie():
+    return Movie()
+
+
+def makeMovieFromInitialFile(filename):
+    import re
+    movie = Movie()
+    global mediaFolder
+    filename = filename.replace('/', os.sep)
+    sep_location = filename.rfind(os.sep)
+    if(-1 == sep_location):
+        filename = mediaFolder + filename
+
+    movie.directory = filename[:(filename.rfind(os.sep))]
+    movie.init_file = filename[(filename.rfind(os.sep)) + 1:]
+    regex = re.compile('[0-9]+')
+    file_regex = regex.sub('.*', movie.init_file)
+
+    for item in sorted(os.listdir(movie.directory)):
+        if re.match(file_regex, item):
+            movie.addFrame(movie.directory + os.sep + item)
+
+    return movie
+
+
+def addFrameToMovie(a, b):
+    frame = None
+    movie = None
+    if a.__class__ == Movie:
+        movie = a
+        frame = b
+    else:
+        movie = b
+        frame = a
+
+    if not (isinstance(movie, Movie) and isinstance(frame, str)):
+        print("addFrameToMovie(frame, movie): frame is not a string or movie is not a Movie object")
+        raise ValueError
+
+    movie.addFrame(frame)
+
+
+def writeFramesToDirectory(movie, directory=None):
+    if not isinstance(movie, Movie):
+        print("writeFramesToDirectory(movie[, directory]): movie is not a Movie object")
+        raise ValueError
+
+    if directory == None:
+        directory = user.home
+
+    movie.writeFramesToDirectory(directory)