def run():
parser = argparse.ArgumentParser(description='Generate TOC for JShop')
parser.add_argument('doi_file', help='Input DOI deposit file')
parser.add_argument('pdf_file', help='Input PDF deposit file')
parser.add_argument('-l',
'--level',
default=1,
help='TOC level to which to parse to')
args = parser.parse_args()
# Get a (simple) list of the chapters
outline = Outline(path.abspath(args.pdf_file), args.level)
chapters = outline.get_chapter_list()
# Make a dictionary with chapters with DOI and related info
# (author name(s), chapter title and PDF URL)
doi_chapters = get_doi_chapters(path.abspath(args.doi_file))
# Merge in data the information of the first list
# and the dictionary
data = []
for chapter in chapters:
for doi_chapter in doi_chapters:
# Find (fuzzy) string matches
if check_match(chapter, doi_chapter) > 90:
data.append({doi_chapter: doi_chapters[doi_chapter]})
break
else:
data.append(chapter)
generate_toc(data)
def submitJob(jobData):
"""Submit the job using the PyOutline API."""
outline = Outline(jobData['name'],
shot=jobData['shot'],
show=jobData['show'],
user=jobData['username'])
lastLayer = None
for layerData in jobData['layers']:
if layerData.layerType == JobTypes.JobTypes.MAYA:
layer = buildMayaLayer(layerData, lastLayer)
elif layerData.layerType == JobTypes.JobTypes.SHELL:
layer = buildShellLayer(layerData, lastLayer)
elif layerData.layerType == JobTypes.JobTypes.NUKE:
layer = buildNukeLayer(layerData, lastLayer)
elif layerData.layerType == JobTypes.JobTypes.BLENDER:
layer = buildBlenderLayer(layerData, lastLayer)
else:
raise ValueError('unrecognized layer type %s' %
layerData.layerType)
outline.add_layer(layer)
lastLayer = layer
if 'facility' in jobData:
outline.set_facility(jobData['facility'])
return cuerun.launch(outline, use_pycuerun=False)
def squareWithHole() -> Outline:
outline = Outline(None)
outline.addLinesFromCoordinateList([[0, 0], [50, 0], [50, 50], [0, 50],
[0, 0]])
circle = a.Arc(Point(35, 25), Point(35, 25), c.CW, Point(25, 25))
outline.addLineGroup(circle)
return outline
def __init__(self):
self._objectNumber = 0
self.objects = list()
self.catalog = Catalog(self)
self.outline = Outline(self)
self.pageTree = PageTree(self)
self.catalog.outlinesNumber = self.outline.objectNumber
self.catalog.pageTreeNumber = self.pageTree.objectNumber
def rightGrip() -> Outline:
outline = Outline(None)
outline.addLinesFromCoordinateList([[82.5, 0], [82.5, 9.5], [49.642, 9.5]])
arc = a.Arc(Point(49.642, 9.5), Point(28.5, 6.5), c.CW, Point(28.5, 82.5),
20)
outline.addLineGroup(arc)
outline.addLinesFromCoordinateList([[28.5, 6.5], [28.5, 0]])
outline.addLineGroup(outline.mirror(c.X))
return outline.translate(82.5, 9.5)
def testSimpleDogBone() -> Outline:
temp = Outline(None)
temp.addLinesFromCoordinateList([[82.5, 0], [82.5, 9.5], [49.642, 9.5],
[28.5, 6.5], [0, 6.5]])
temp.addLineGroup(temp.mirror(c.Y))
temp.addLineGroup(temp.mirror(c.X))
temp = temp.translate(82.5, 9.5)
temp.finishOutline()
return temp
def main(input_path, fps, crf, chunk, output_path):
"""
Sends a job to opencue that will compress an image sequence to
an H.264 file using multiple render nodes in parallel
:input_path: str - path to the first frame of the image sequence
:fps: float - framerate of the desired encoded file
:crf: int - quality of the desired encoded file
"""
input_path = os.path.abspath(input_path)
shot_name = os.path.basename(input_path)
job_name = "dpx_to_mov"
show_name = "testing"
user = getpass.getuser()
outline = Outline(job_name, shot=shot_name, show=show_name, user=user)
# Create the MakeMov Layer
layer_name = "seq_to_mov"
threads = 1.0
threadable = False
frame_start, frame_end = get_imgseq_framerange(input_path)
range_len = int(frame_end) - int(frame_start)
frame_range = frame_start + "-" + frame_end
input_path_ffmpeg = translate_imgseq_ffmpeg(input_path)
output_chunk_path_template = create_chunk_path_template(input_path)
seqtomov_layer = SeqToMov(layer_name,
chunk=chunk,
threads=threads,
range=frame_range,
threadable=threadable,
crf=crf,
fps=fps)
seqtomov_layer.add_input("main", input_path_ffmpeg)
seqtomov_layer.add_output("main", output_chunk_path_template)
outline.add_layer(seqtomov_layer)
# Create the ConcatMov Layer
layer_name = "concat_mov"
concatmov_layer = ConcatMov(layer_name,
chunk=1,
threads=threads,
range=1,
threadable=threadable)
chunk_paths = get_chunk_paths(output_chunk_path_template, chunk,
frame_start, frame_end)
for chunk_path in enumerate(chunk_paths):
concatmov_layer.add_input("", chunk_path)
concatmov_layer.add_output("main", output_path)
concatmov_layer.depend_all(seqtomov_layer)
outline.add_layer(concatmov_layer)
# Submit job
cuerun.launch(outline, use_pycuerun=False)
def rectangle(lowerLeftX: float, lowerLeftY: float, X_width: float,
Y_height: float) -> Outline:
rect = [Point(lowerLeftX, lowerLeftY)]
rect.append(Point(lowerLeftX + X_width, lowerLeftY))
rect.append(Point(lowerLeftX + X_width, lowerLeftY + Y_height))
rect.append(Point(lowerLeftX, lowerLeftY + Y_height))
rectLG = Outline(None)
rectLG.addLinesFromPoints(rect)
rectLG.closeShape()
return rectLG
def regularDogBone() -> Outline:
dogBone = Outline(None)
dogBone.addLinesFromCoordinateList([[82.5, 0], [82.5, 9.5], [49.642, 9.5]])
arc = a.Arc(Point(49.642, 9.5), Point(28.5, 6.5), c.CW, Point(28.5, 82.5),
20)
dogBone.addLineGroup(arc)
dogBone.addLinesFromCoordinateList([[28.5, 6.5], [0, 6.5]])
dogBone.addLineGroup(dogBone.mirror(c.Y))
dogBone.addLineGroup(dogBone.mirror(c.X))
dogBone = dogBone.translate(82.5, 9.5)
dogBone.finishOutline()
dogBone._name = 'regularDogBone'
return dogBone
def polygon(centerX: float, centerY: float, radius: float,
numCorners: int) -> Outline:
angle = 1.5 * math.pi
points = []
incAngle = 2 * math.pi / numCorners
for i in range(numCorners):
x = math.cos(angle + incAngle * i) * radius + centerX
y = math.sin(angle + incAngle * i) * radius + centerY
points.append(Point(x, y))
poly = Outline(None)
poly.addLinesFromPoints(points)
poly.closeShape()
poly = poly.rotate(incAngle / 2.0, Point(centerX, centerY))
return poly
def wideDogBone(gageWidth: float) -> Outline:
halfWidth = gageWidth / 2.0
wideDogBone = Outline(None)
wideDogBone.addLinesFromCoordinateList([[82.5, 0], [82.5, 9.5 + halfWidth],
[49.642, 9.5 + halfWidth]])
wideArc = a.Arc(Point(49.642, 9.5 + halfWidth),
Point(28.5, 6.5 + halfWidth), c.CW,
Point(28.5, 82.5 + halfWidth), 20)
wideDogBone.addLineGroup(wideArc)
wideDogBone.addLinesFromCoordinateList([[28.5, 6.5 + halfWidth],
[0, 6.5 + halfWidth]])
wideDogBone.addLineGroup(wideDogBone.mirror(c.Y))
wideDogBone.addLineGroup(wideDogBone.mirror(c.X))
return wideDogBone.translate(82.5, 9.5 + halfWidth)
def submitJob(jobData):
"""Submit the job using the PyOutline API."""
outline = Outline(jobData['name'],
shot=jobData['shot'],
show=jobData['show'],
user=jobData['username'])
for layerData in jobData['layers']:
if layerData.layerType == JobTypes.JobTypes.MAYA:
layer = buildMayaLayer(layerData)
elif layerData.layerType == JobTypes.JobTypes.SHELL:
layer = buildShellLayer(layerData)
elif layerData.layerType == JobTypes.JobTypes.NUKE:
layer = buildNukeLayer(layerData)
outline.add_layer(layer)
return cuerun.launch(outline, use_pycuerun=False)
def add_outline(self):
"""
Adds the contents of the AddOtlineWindow to the database.
"""
outline = Outline()
outline_number = self.line_number.displayText()
outline_title = self.line_title.displayText()
submission = outline.add_outline(outline_number, outline_title)
if submission[0] == "True":
self.done(True)
else:
error = QtGui.QMessageBox.critical(self, 'Error', submission[1])
def save_edit(self):
"""
Save edits made by the user to the selected outline.
"""
number = self.line_number.displayText()
title = self.line_title.displayText()
outline = Outline()
submission = outline.edit_outline(self.edited_item[0][1],
self.edited_item[0][2], number,
title, self.edited_item[0][0])
if submission[0] == 'True':
self.done(True)
else:
error = QtGui.QMessageBox.critical(self, 'Error', submission[1])
def regularDogBoneFillet(scale: float) -> Outline:
dogBoneF = Outline(None)
dogBoneF.addLinesFromCoordinateList([[82.5, 0], [82.5, 4.5]])
arc = a.Arc(Point(82.5, 4.5), Point(77.5, 9.5), c.CCW, Point(77.5, 4.5),
6) #5mm fillet
dogBoneF.addLineGroup(arc)
dogBoneF.addLinesFromCoordinateList([[77.5, 9.5], [49.642, 9.5]])
arc = a.Arc(Point(49.642, 9.5), Point(28.5, 6.5), c.CW, Point(28.5, 82.5),
20)
dogBoneF.addLineGroup(arc)
dogBoneF.addLinesFromCoordinateList([[28.5, 6.5], [0, 6.5]])
dogBoneF.addLineGroup(dogBoneF.mirror(c.Y))
dogBoneF.addLineGroup(dogBoneF.mirror(c.X))
dogBoneF = dogBoneF.translate(82.5, 9.5)
dogBoneF.finishOutline()
dogBoneF = dogBoneF.scale(scale)
dogBoneF._name = 'regularDogBoneFillet'
return dogBoneF
def typeVDogBone(scale: float) -> Outline:
typeV = Outline(None)
typeV.addLinesFromCoordinateList([[31.75, 0], [31.75, 3.77]])
arc = a.Arc(Point(31.75, 3.77), Point(30.75, 4.77), c.CCW,
Point(30.75, 3.77), 5) #1mm fillet
typeV.addLineGroup(arc)
typeV.addLinesFromCoordinateList([[30.75, 4.77], [13.17, 4.77]])
arc = a.Arc(Point(13.17, 4.77), Point(4.77, 1.59), c.CW,
Point(4.77, 14.29))
typeV.addLineGroup(arc)
typeV.addLinesFromCoordinateList([[4.77, 1.59], [0, 1.59]])
typeV.addLineGroup(typeV.mirror(c.Y))
typeV.addLineGroup(typeV.mirror(c.X))
typeV = typeV.translate(31.75, 4.77)
typeV.finishOutline()
typeV = typeV.scale(scale)
typeV._name = 'typeVDogBone'
return typeV
def _doDispatch(self, rootBatch):
# Construct an object to track everything we need
# to generate the job. I have a suspicion that at
# some point we'll want a Dispatcher::Job base class
# which _doDispatch() must return, in which case this
# might just be member data for a subclass of one of those.
dispatchData = {}
dispatchData["scriptNode"] = rootBatch.preTasks()[0].node().scriptNode(
)
dispatchData["scriptFile"] = Gaffer.Context.current(
)["dispatcher:scriptFileName"]
dispatchData["batchesToLayers"] = {}
# Create an OpenCue outline and set its basic properties.
context = Gaffer.Context.current()
outline = Outline(
context.substitute(self["jobName"].getValue()) or "untitled",
show=context.substitute(self["showName"].getValue()) or "show",
shot=context.substitute(self["shotName"].getValue()) or "shot",
user=context.substitute(self["userName"].getValue()) or "user",
)
# Populate the job with tasks from the batch tree
# that was prepared by our base class.
for upstreamBatch in rootBatch.preTasks():
self.__buildOutlineWalk(outline, upstreamBatch, dispatchData)
# Signal anyone who might want to make just-in-time
# modifications to the job.
self.preSpoolSignal()(self, outline)
# Finally, we can spool the job.
cuerun.launch(outline, use_pycuerun=False)
def __init__(self,
trimOutline,
pathWidth,
angleDegrees,
shiftX=0,
shiftY=0,
design=None,
designType=c.PARTIAL_ROW):
LineGroup.__init__(self, None)
self.shiftX = shiftX
self.shiftY = shiftY
self.designType = designType
self.trimOutline = Outline(trimOutline)
self.angleRad = (angleDegrees / 360.0 * 2 * np.pi)
self.pathWidth = pathWidth
lowerLeft = Point(self.trimOutline.minX, self.trimOutline.minY)
upperRight = Point(self.trimOutline.maxX, self.trimOutline.maxY)
self.trimDiagonal = (lowerLeft - upperRight) * 1.1
self.operations = (self.extendDesign, self.createField,
self.centerAndRotateField, self.trimField)
try:
self.design = design(
space=self.pathWidth,
length=self.trimDiagonal,
height=self.trimDiagonal,
)
self.designType = c.FULL_FIELD
except Exception:
self.design = LineGroup(design)
# print('\nInfill times:')
for i in range(self.designType, c.TRIMMED_FIELD):
startTime = time.time()
self.operations[i]()
return cv.divide(gray, 255 - blur, scale=256)
# Open the image
img = Image.open(filename)
# Get the image after applying the Drawing class to it
# This will create the image as a lighter pencil sketch, with background noise nor major edge detection applied
drawing = Drawing(filename).drawing()
cv.imwrite("drawing.png", drawing)
# Apply background noise to image (see background_noise.py for process)
background = BackgroundNoise(img.size, levels=6).background_noise()
# Apply outline to image (see outline.py for process)
outline = Outline(filename).outline()
# Set the mask as the third matrix created by the outline function
mask = outline[3]
# Combine the outline (major edges) with the light pencil sketch to accentuate the major edges
drawing = cv.bitwise_and(drawing, outline, outline)
# Threshold is set to each pixel in the drawing. If the pixel value is set below the threshold (240) assigned 0. 255 is the max which is assigned to pixel values
# exceeding the threshold. THRESH_BINARY applies a simple piece-wise function to apply the threshold:
# dst(x,y) = {maxval if src(x,y) > threshold}
# {0 otherwise}
(threshold, drawing) = cv.threshold(drawing, 240, 255, cv.THRESH_BINARY)
# The height and width are set to the current image dimensions
height, width = drawing.shape[:2]
#!/bin/env python2.5
# Copyright (c) 2018 Sony Pictures Imageworks Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from outline import Outline, cuerun
from outline.modules.tutorial import HelloModule
ol = Outline("my_job")
ol.add_layer(HelloModule("my_layer"))
cuerun.launch(ol, range="1-10", pause=True)
secAngs = []
meshes = []
with open(path + paramFile, 'r') as fp:
data = json.load(fp)
params = Parameters(data[0], data[1])
for fname, color, angle in zip(fnames, colors, angles):
mesh = trimesh.load_mesh(path + fname)
meshes.append(mesh)
section = mesh.section(plane_origin=[0, 0, 0.01], plane_normal=[0, 0, 1])
loops = section.discrete
for loop in loops:
outline = Outline()
outline._name = fname
outline.addCoordLoop(loop * 1000) # 1000 to convert from meters to mm
outline = outline.translate(-50, -12)
secAngs.append(SecAng(Section(outline), angle))
plt.plot(loop[:, 0] - 0.050, loop[:, 1] - 0.012, color)
params.outline = [tuple(secAngs)]
gCode = Gcode(params)
plt.show()
def run():
startTime = time.time()
print('\nGenerating code, please wait...')
'show':
'inside_job',
'username':
user,
'layers': [
Layer.LayerData.buildFactory(**NUKE_RENDER_EXR),
Layer.LayerData.buildFactory(**FFMPEG_LAYER),
Layer.LayerData.buildFactory(**NUKE_POST_TO_DISCORD),
Layer.LayerData.buildFactory(**NUKE_POST_TO_FTRACK),
Layer.LayerData.buildFactory(**NUKE_UPDATE_EDIT),
]
}
# SUBMIT ############################################################
outline = Outline(jobData['name'],
shot=jobData['shot'],
show=jobData['show'],
user=jobData['username'])
layers = []
for layerData in jobData['layers']:
layer = Shell(layerData.name,
command=layerData.cmd.split(),
chunk='1',
threads=float(layerData.cores),
range=str(layerData.layerRange),
threadable=True)
layer.set_service(layerData.services[0])
layers.append(layer)
layer_count = 0
for layer in layers:
if layer_count > 0:
def center() -> Outline:
outline = Outline(None)
outline.addLinesFromCoordinateList([[28.5, 6.5], [-28.5,
6.5], [-28.5, -6.5],
[28.5, -6.5], [28.5, 6.5]])
return outline.translate(82.5, 9.5)
"""
import os
import sys
import getpass
import datetime
from modules.debug import DebugLayer
from outline import Outline, cuerun
# Create an outline for the job
job_name = "debug_job"
shot_name = "debug_shot"
show_name = "testing"
user = getpass.getuser()
outline = Outline(job_name, shot=shot_name, show=show_name, user=user)
# Create the debug Layer
layer_name = "debug_layer"
chunk_size = 1
threads = 1.0
threadable = False
frame_range = "1"
debug_layer = DebugLayer(layer_name,
input="input_path",
output="output_path",
chunk=chunk_size,
threads=threads,
range=frame_range,
threadable=threadable,
def circle(centerX: float, centerY: float, radius: float) -> Outline:
startPoint = Point(centerX + radius, centerY)
center = Point(centerX, centerY)
return Outline(a.Arc(startPoint, startPoint, c.CW, center, numPoints=40))
