|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object kdl.prox.qgraph2.util.QGUtil
public class QGUtil
This class encapsulates graph operations that are mainly used by qGraph but can also be used from other packages.
It provides operations such as getMatchingObjects/Links which, given a condition. return the list of objects/links that match it. It also provides getObjectsConnectedVia(Un)DirectedLinks which, given two NSTs with objects and one NST with links, returns an NST with the list of the way in which those objects are connected via those links. More closely related to qGraph, there is a method called connectConsolidatedVertices which receives two SGI tables and a qGraph edge, and it creates a new SGI table with the connected consolidated vertices. Finally, there is a reCheckLinks method that, given a table of links and a table of objects (in the subgraph format), will make sure that the links are actually connecting elements in the objects table. If an instance of this class is created with a Container that is not null, then all the operations are limited to that container. Therefore, getMatchingLinks will for example return the list of links that match a condition, not from the universe of all links in the database but only from the list of links in the container. The class creates some intermediate NSTs and BATs that need to be accessible until the class is not needed anymore. Users of this class are expected to call the release() method when they're done using it.
| Constructor Summary | |
|---|---|
QGUtil(Container sourceContainer)
|
| Method Summary | |
|---|---|
NST |
connectConsolidatedVertices(QGEdge qgEdgeY,
NST aObjTempSGINST,
NST bObjTempSGINST,
java.lang.String vertexAName,
java.lang.String vertexBName)
Used by TFM 02 and TFM 12 A complicated routine that combines two consolitades vertices (represented by the ObjTempSGINST tables) Finds all links of type Y, As in vertex A, Bs in vertex B, and connects them, Removes rows that do not match the Y annotation and recomputes subg_id if there is an expansion because no annotation is present Returns a table with the following format a_(item_id subg_id name) o1_id o2_id link_id b_(item_id ...) new_subg_id The resulting NST is materialized |
NST |
getMatchingLinks(org.jdom.Element condEleChild)
Finds all the links that match a given condition Returns an NST with [o1_id o2_id link_id] Most of the work is done by |
NST |
getMatchingObjects(org.jdom.Element condEleChild)
Finds all the objects that match a given condition Returns an NST with [o_id] |
NST |
getObjectsConnectedViaDirectedLinks(NST aObjs,
NST bObjs,
NST links,
boolean isReverseDir)
Given a list of objects A, a list of objects B, and a set of links L this method does two joins to compute A X B, that is, an NST with the columns from A, L and B and rows such that A.item_id = L.o1_id && B.item_id = L.o2_id (if isReverseDir, then A.item_id = L.o2_id && B.item_id = L.o1_id) The join is done incrementally, with two calls to the NST join constructor In the first pass, aObjs is joined with L (item_id = o1_id) in the second pass, the result above is joined with B (o2_id = item_id) The object lists may come as a consolidated vertex, with (item_id, subg_id, name) or simply as a list of IDS (o_id). |
NST |
getObjectsConnectedViaUndirectedLinks(NST aObjs,
NST bObjs,
NST links)
Given a list of objects A, a list of objects B, and a set of links L this method gets the list of connections, irrespective of the direction of the links It works by calling getObjectsConnectedViaDirectedLinks twice and then merging the results The object lists may come as a consolidated vertex, with (item_id, subg_id, name) or simply as a list of IDS (o_id). |
void |
reCheckLinks(NST origLinkTempSGINST,
NST newObjectTempSGINST,
java.lang.String itemName,
java.lang.String[] incidentEdges,
NST newLinkTempSGINST)
Check that the links left in the link table still connect objects in the new object table. |
void |
release()
Releases any vars created during calls to other public methods. |
| Methods inherited from class java.lang.Object |
|---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Constructor Detail |
|---|
public QGUtil(Container sourceContainer)
| Method Detail |
|---|
public NST connectConsolidatedVertices(QGEdge qgEdgeY, NST aObjTempSGINST, NST bObjTempSGINST, java.lang.String vertexAName, java.lang.String vertexBName)
qgEdgeY
- aObjTempSGINST
- bObjTempSGINST
- vertexAName
- vertexBName
-
public NST getMatchingLinks(org.jdom.Element condEleChild)
condEleChild
-
public NST getMatchingObjects(org.jdom.Element condEleChild)
condEleChild
-
public NST getObjectsConnectedViaDirectedLinks(NST aObjs, NST bObjs, NST links, boolean isReverseDir)
aObjs
- bObjs
- links
- isReverseDir
-
public NST getObjectsConnectedViaUndirectedLinks(NST aObjs, NST bObjs, NST links)
aObjs
- bObjs
- links
-
public void reCheckLinks(NST origLinkTempSGINST, NST newObjectTempSGINST, java.lang.String itemName, java.lang.String[] incidentEdges, NST newLinkTempSGINST)
origLinkTempSGINST
- newObjectTempSGINST
- itemName
- incidentEdges
- newLinkTempSGINST
- public void release()
|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


The specific branch for Code Dx to fetch from its configured Git source. If not set, the default branch from the project's Git config will be used.
Note: this field has no interactions with the "Target Branch" field, which specifies the project's Code Dx branch to associate findings with.


module Money::Arithmetic
Direct including types
Defined in:
money/money/arithmetic.crInstance Method Summary
-
#%(other) : Money
Alias of
#modulo
. -
#*(other : Number) : Money
Multiplies the monetary value with the given other
Number
and returns a newMoney
object with this monetary value and the same#currency
. -
#+(other : Money) : Money
Returns a new
Money
object containing the sum of the two operands' monetary values. -
#+ : Money
Alias of
#abs
. -
#-(other : Money) : Money
Returns a new
Money
object containing the difference between the two operands' monetary values. -
#- : Money
Returns a new
Money
object with changed polarity. -
#/(other : Number) : Money
Divides the monetary value with the given other
Number
and returns a newMoney
object with this monetary value and the same#currency
. -
#/(other : Money) : BigDecimal
Divides the monetary value with the given other
Money
object and returns a ratio. -
#abs : Money
Returns absolute value of
self
as a newMoney
object. -
#divmod(other : Money) : ::Tuple(BigInt, Money)
Divide by
Money
orNumber
and returnTuple
containing quotient and modulus. -
#divmod(other : Number) : ::Tuple(Money, Money)
Divide by
Money
orNumber
and returnTuple
containing quotient and modulus. -
#modulo(other) : Money
Equivalent to
#divmod(other)[1]
. -
#negative?
Returns
true
if the money amount is less than 0,false
otherwise. -
#positive?
Returns
true
if the money amount is greater than 0,false
otherwise. -
#remainder(other : Number) : Money
If different signs
#modulo(other) - other
, otherwise#modulo(other)
. -
#round(precision : Int? = 0) : Money
Rounds the monetary amount to smallest unit of coinage.
-
#zero?
Returns
true
if the money amount is zero.
Instance Method Detail
Multiplies the monetary value with the given other Number
and returns
a new Money
object with this monetary value and the same #currency
.
Money.new(100) * 2 # => Money(@amount=2)
Returns a new Money
object containing the sum of the two
operands' monetary values.
Money.new(100) + Money.new(100) # => Money(@amount=2)
Returns a new Money
object containing the difference between the two
operands' monetary values.
Money.new(100) - Money.new(99) # =><EMAIL_ADDRESS>Returns a new Money
object with changed polarity.
-Money.new(100) # => Money(@amount=-1)
Divides the monetary value with the given other Number
and returns
a new Money
object with this monetary value and the same #currency
.
Money.new(100) / 10 # =><EMAIL_ADDRESS>Divides the monetary value with the given other Money
object and
returns a ratio.
Money.new(100) / Money.new(10) # => 10.0
Returns absolute value of self
as a new Money
object.
Money.new(-100).abs # => Money(@amount=1)
Divide by Money
or Number
and return Tuple
containing
quotient and modulus.
Money.new(100).divmod(9) # => {Money(@amount=0.11), Money(@amount=0.01)}
Money.new(100).divmod(Money.new(9)) # => {11, Money(@amount=0.01)}
Divide by Money
or Number
and return Tuple
containing
quotient and modulus.
Money.new(100).divmod(9) # => {Money(@amount=0.11), Money(@amount=0.01)}
Money.new(100).divmod(Money.new(9)) # => {11, Money(@amount=0.01)}
Equivalent to #divmod(other)[1]
.
Money.new(100).modulo(9) # =><EMAIL_ADDRESS>Money.new(100).modulo(Money.new(9)) # =><EMAIL_ADDRESS>Returns true
if the money amount is less than 0, false
otherwise.
Money.new(-1).negative? # => true
Money.new(0).negative? # => false
Money.new(1).negative? # => false
Returns true
if the money amount is greater than 0, false
otherwise.
Money.new(1).positive? # => true
Money.new(0).positive? # => false
Money.new(-1).positive? # => false
If different signs #modulo(other) - other
, otherwise #modulo(other)
.
Money.new(100).remainder(9) # =><EMAIL_ADDRESS>Rounds the monetary amount to smallest unit of coinage.
Money.new(10.1, "USD").round # => Money(@amount=10, @currency="USD")
Returns true
if the money amount is zero.
Money.new(0).zero? # => true
Money.new(100).zero? # => false
Money.new(-100).zero? # => false


Ok you dont know what the konami code is? Come on. Ill leave it below.
Press the following keys in sequence on your keyboard:


PIZZA ORDER
select size
Extra Large $16
Large $14
medium $12
small $10
TOPPINGS $1.50 Each.
Choose a Topping
Pepperoni
Sausage
Pineapple
onions
Mushrooms
Ham
Duck
Choose a Topping
Pepperoni
Sausage
Pineapple
onions
Mushrooms
Ham
Duck
Choose a Topping
Pepperoni
Sausage
Pineapple
onions
Mushrooms
Ham
Duck
Choose a Topping
Pepperoni
Sausage
Pineapple
onions
Mushrooms
Ham
Duck
Submit
TOTAL ORDER PRICE


Exchange MoynKey
Error form!


--- layout: default ---
In 2012, I conducted research into the state of open educational reseources. My task wasn’t simply to identify where the repositories of OER exist or what they contain. Nor was I just looking at adoption or usage (although yes, the research did address all these things.) I was particularly keen to investigate the formats that these openly licensed materials are in, and by an extension whether they’re being remixed.
This work was sponsored by FunnyMonkey.
OER Repositories and Directories


Travel Log
360 VR Panorama
Video
List Of Visited Contries
Argentina
Brazil
Colombia
Denmark
Thailand
USA
Image Gallery
Contact And Social Network
@firt
Call Me
Send Via WhatsApp


Source code for pipeline
"""
Created on May 4, 2018
@author: D/vidr
"""
from boto.s3.key import Key
from google.cloud import vision
from google.cloud.vision import types
from io import BytesIO
from PIL import Image
import skimage.io as skio
import base64
import boto
import cv2
import io
import numpy as np
import re
import sys
from text_processingv3 import simple_process
# import os
# os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = \
# def detect_text(uri):
# """Detects text in the file located in
# Google Cloud Storage or on the Web.
# """
# client = vision.ImageAnnotatorClient()
# image = types.Image()
# image.source.image_uri = uri
#
# response = client.text_detection(image=image)
# texts = response.text_annotations
#
# return (texts, texts[0].description.encode('ascii',
# 'ignore').decode('ascii'))
[docs]def download_img(img_url):
"""Download image from url.
"""
img = skio.imread(img_url)
return img
[docs]def detect_text(path):
"""Detects text in the file from local"""
client = vision.ImageAnnotatorClient()
with io.open(path, 'rb') as image_file:
content = image_file.read()
image = types.Image(content=content)
response = client.text_detection(image=image)
texts = response.text_annotations
return (texts, texts[0].description.encode('ascii',
'ignore').decode('ascii'))
[docs]def readImagefromS3(imageFile):
"""
This function will be using the pem file for AWS.
It will access a public S3 bucket called dvidr with
the specified image file. The output is a url link
for the image that will be passed onto the Google
Cloud Vision API for processing.
"""
with open('../../../dvidr.pem') as f:
keys = f.read().split(',')
s3 = boto.connect_s3(
aws_access_key_id=keys[0],
aws_secret_access_key=keys[1]
)
bucket = s3.get_bucket("dvidr", validate=False)
k1 = Key(bucket)
k1.key = imageFile
url_name = k1.generate_url(259200)
return url_name
# def bounding_box(url, texts):
# """add bounding box to image, return image numpy array
# """
# img = skio.imread(url)
# for text in texts[1:]: # 0th bounding box is whole picture
# vertices = [(vertex.x, vertex.y) # get coordinates
# for vertex in text.bounding_poly.vertices]
# cv2.polylines(img, [np.array(vertices)],
# True, (0, 255, 0), 2) # plot line
#
# return img
[docs]def bounding_box(img_path, texts):
"""add bounding box to straightened image, return image numpy array
"""
# read image from local
img = cv2.imread(img_path)
# convert to RGB
if len(img.shape) == 2:
img = cv2.cvtColor(img, cv2.COLOR_GRAY2RGB)
else:
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
for text in texts[1:]: # 0th bounding box is whole picture
vertices = [(vertex.x, vertex.y) # get coordinates
for vertex in text.bounding_poly.vertices]
cv2.polylines(img, [np.array(vertices)],
True, (0, 255, 0), 2) # plot line
return img
[docs]def arr2str(img_arr):
"""convert a image from numpy array to base64 output
"""
pil_img = Image.fromarray(img_arr)
buff = BytesIO()
pil_img.save(buff, format="JPEG")
new_image_string = base64.b64encode(buff.getvalue()).decode("utf-8")
new_image_string = "data:image/jpg;base64," + new_image_string
return new_image_string
if __name__ == '__main__':
filepath = (readImagefromS3("85c.jpg"))
texts = detect_text(filepath)[0]
print(texts)
output = simple_process(texts)
print(output)


I just tried to swap from v2 to v3 hardware but the inputs are not in the same order. ie. voltage is coming up on the old ct2 input field and ct3 data is coming in on the original voltage field etc.
Is there a way of rearranging the inputs such as editing the key numbers on the input page?
I'm using emoncms v8.01 on rpi with emonTxV3_continuous_kwhtotals_noeeprom firmware on the emontx.
Re: changed from emontx v2 to v3 now inputs jumbled up
The easiest way is to delete your 'log to Feed' process within your input page, and add a new 'log to feed' process directing the input to your correct & respective feed.
The alternative is to re-program the emontx v3 to send the cvs string in a different order, as the keys are assigned by emoncms in the order that the data is received.
Paul
Re: changed from emontx v2 to v3 now inputs jumbled up
I was hoping I wouldn't have to re-input all the log to feed processes as there is loads of them. I'll look into reprogramming the emontx v3 first.
Re: changed from emontx v2 to v3 now inputs jumbled up
It's only deleting one process and adding one process per input, you won't lose your other processes or existing feed data, but whichever option you feel most comfortable with.
Paul
Re: changed from emontx v2 to v3 now inputs jumbled up
I've just found that I can edit the key number on the input page in v8.01 by clicking on the pen icon. This re-arranges the processes . I'll try it out tomorrow but it looks as though this will solve the problem.
Re: changed from emontx v2 to v3 now inputs jumbled up
If you go down the route of editing the key numbers don't do it to a live node. be sure to power down the node in question as it gets quite confusing if emoncms tries to re allocate keys because it received a packet when you're mid edit :-)


Welcome to the Pizza Factory!
Name for the order:
Select Pizza Size:
Small
Medium
Large
Select your toppings:
Pepperoni
Sausage
Pineapple
Bacon
Submit
your pizza costs
. Come back soon!


Before Change
context_features = tf.ones([2, 2, 3], tf.float32)
valid_mask = tf.constant([[True, True], [False, False]], tf.bool)
is_training = False
projection_layers = {context_rcnn_lib.KEY_NAME: context_rcnn_lib.ContextProjection(bottleneck_dimension, False), context_rcnn_lib.VALUE_NAME: context_rcnn_lib.ContextProjection(bottleneck_dimension, False),
context_rcnn_lib.QUERY_NAME: context_rcnn_lib.ContextProjection(bottleneck_dimension, False)}
//Add in the feature layer because this is further down the pipeline and it isn"t automatically injected.
projection_layers["feature"] = context_rcnn_lib.ContextProjection(output_dimension, False)
After Change
//Add in the feature layer because this is further down the pipeline and it isn"t automatically injected.
//projection_layers["feature"] = context_rcnn_lib.ContextProjection(output_dimension, False)
attention_block = context_rcnn_lib.AttentionBlock(bottleneck_dimension, attention_temperature, False)
attention_block.set_output_dimension(output_dimension)
output_features = attention_block([input_features, context_features], is_training, valid_mask)
// Makes sure the shape is correct.


Our couriers are at the heart of what we do. They represent us in the streets, delivering parcels with a smile on behalf of our customers. Join an open and inspiring community of professional couriers and deliver better with Dropwit
Our couriers are at the heart of what we do. They represent us in the streets, delivering parcels with a smile on behalf of our customers. Join an open and inspiring community of professional couriers and deliver better with Dropwit
We’ve worked hard at making Dropwit the most attractive place to work. With a range of benefits and our support to develop your career as a self-employed professional courier, there’s no reason not to join.
At Dropwit you’re paid an hourly fee. You also get extra fees for every delivery you make as keep any tips
You’re in control of your work hours. We operate all day, so you can work when it suits your schedule
Be part of a fast-growing, friendly and supportive community of professional self-employed couriers.


| Modifier and Type | Class and Description |
|---|---|
class |
AbstractPhysicalVisitor<T,X,E extends Throwable> |
| Modifier and Type | Method and Description |
|---|---|
<T,X,E extends Throwable> |
AbstractStore.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
<T,X,E extends Throwable> |
AbstractWriter.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
<T,X,E extends Throwable> |
PhysicalOperator.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value)
Provides capability to build a set of output based on traversing a query graph tree.
|
<T,X,E extends Throwable> |
AbstractSubScan.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
<T,X,E extends Throwable> |
AbstractGroupScan.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
<T,X,E extends Throwable> |
AbstractReceiver.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
<T,X,E extends Throwable> |
AbstractExchange.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
<T,X,E extends Throwable> |
AbstractJoinPop.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
<T,X,E extends Throwable> |
AbstractSender.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
| Modifier and Type | Method and Description |
|---|---|
<T,X,E extends Throwable> |
BroadcastSender.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
<T,X,E extends Throwable> |
PartitionLimit.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
<T,X,E extends Throwable> |
Sort.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
<T,X,E extends Throwable> |
MetadataHandlerPOP.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
<T,X,E extends Throwable> |
StatisticsMerge.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
<T,X,E extends Throwable> |
Values.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
<T,X,E extends Throwable> |
StreamingAggregate.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
<T,X,E extends Throwable> |
OrderedPartitionSender.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
<T,X,E extends Throwable> |
SelectionVectorRemover.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
<T,X,E extends Throwable> |
MetadataControllerPOP.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
<T,X,E extends Throwable> |
TopN.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
<T,X,E extends Throwable> |
WindowPOP.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
<T,X,E extends Throwable> |
Limit.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
<T,X,E extends Throwable> |
UnorderedReceiver.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
<T,X,E extends Throwable> |
ProducerConsumer.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
<T,X,E extends Throwable> |
StatisticsAggregate.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
<T,X,E extends Throwable> |
UnpivotMaps.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
<T,X,E extends Throwable> |
HashPartitionSender.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
<T,X,E extends Throwable> |
IteratorValidator.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
<T,X,E extends Throwable> |
RangePartitionSender.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
<T,X,E extends Throwable> |
ComplexToJson.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
<T,X,E extends Throwable> |
UnionAll.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
<T,X,E extends Throwable> |
RowKeyJoinPOP.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
<T,X,E extends Throwable> |
Project.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
<T,X,E extends Throwable> |
RuntimeFilterPOP.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
<T,X,E extends Throwable> |
LateralJoinPOP.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
<T,X,E extends Throwable> |
FlattenPOP.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
<T,X,E extends Throwable> |
HashAggregate.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
<T,X,E extends Throwable> |
SingleSender.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
<T,X,E extends Throwable> |
Screen.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
<T,X,E extends Throwable> |
UnnestPOP.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
<T,X,E extends Throwable> |
MergingReceiverPOP.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
<T,X,E extends Throwable> |
Trace.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
<T,X,E extends Throwable> |
Filter.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
| Modifier and Type | Class and Description |
|---|---|
class |
TraceInjector |
| Modifier and Type | Class and Description |
|---|---|
class |
IteratorValidatorInjector |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractOpWrapperVisitor<RET,EXCEP extends Throwable> |
| Modifier and Type | Class and Description |
|---|---|
protected static class |
Fragment.BufferedOpFinder |
class |
MakeFragmentsVisitor
Responsible for breaking a plan into its constituent Fragments.
|
class |
Materializer |
class |
MemoryCalculator
A visitor to compute memory requirements for each operator in a minor fragment.
|
protected static class |
SimpleParallelizer.CountRequiredFragments
Designed to setup initial values for arriving fragment accounting.
|
class |
StatsCollector
Visitor to collect stats such as cost and parallelization info of operators within a fragment.
|
| Modifier and Type | Class and Description |
|---|---|
class |
ExchangeRemoverMaterializer
Materializer visitor to remove exchange(s)
NOTE: this Visitor does NOT set OperatorId, as after Exchange removal all operators need renumbering
Use OperatorIdVisitor on top to set correct OperatorId
|
class |
OperatorIdVisitor
Visitor to renumber operators - needed after materialization is done as some operators may be removed
using @ExtendedMaterializerVisitor
|
| Modifier and Type | Method and Description |
|---|---|
<T,X,E extends Throwable> |
DruidSubScan.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
| Modifier and Type | Method and Description |
|---|---|
<T,X,E extends Throwable> |
HBaseSubScan.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
| Modifier and Type | Method and Description |
|---|---|
<T,X,E extends Throwable> |
HiveSubScan.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
| Modifier and Type | Method and Description |
|---|---|
<T,X,E extends Throwable> |
HttpSubScan.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
| Modifier and Type | Method and Description |
|---|---|
<T,X,E extends Throwable> |
KafkaSubScan.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
| Modifier and Type | Method and Description |
|---|---|
<T,X,E extends Throwable> |
KuduSubScan.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
| Modifier and Type | Method and Description |
|---|---|
<T,X,E extends Throwable> |
MapRDBSubScan.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
| Modifier and Type | Method and Description |
|---|---|
<T,X,E extends Throwable> |
MockSubScanPOP.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
| Modifier and Type | Method and Description |
|---|---|
<T,X,E extends Throwable> |
MongoSubScan.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
| Modifier and Type | Method and Description |
|---|---|
<T,X,E extends Throwable> |
OpenTSDBSubScan.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
| Modifier and Type | Method and Description |
|---|---|
<T,X,E extends Throwable> |
AbstractParquetRowGroupScan.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
| Modifier and Type | Class and Description |
|---|---|
protected class |
RuntimeFilterRouter.RuntimeFilterParallelismCollector
Collect the runtime filter parallelism related information such as join node major/minor fragment id , probe side scan node's
major/minor fragment id, probe side node's endpoints.
|
| Modifier and Type | Class and Description |
|---|---|
protected static class |
ThrottledResourceManager.QueuedResourceAllocator.BufferedOpFinder
Searches a fragment operator tree to find buffered within that fragment.
|
| Modifier and Type | Method and Description |
|---|---|
<T,X,E extends Throwable> |
OperatorTestBuilderTest.MockPhysicalOperator.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
<T,X,E extends Throwable> |
PhysicalOpUnitTestBase.MockPhysicalOperator.accept(PhysicalVisitor<T,X,E> physicalVisitor,
X value) |
Copyright © 2021 The Apache Software Foundation. All rights reserved.


--- layout: post date: 2006-04-05 time: "09:00:00" authors: ["Greg Wilson"] title: "New Security Lecture Up" tags: ["Carpentries Lessons"] ---
A new lecture on security is up. It has changed a lot from the hash I presented in the fall; feedback would be very, very welcome.


BE SURE to put a space between the letters and the numbers, or else it wont get scheduled. Ex: CS 115, not CS115.
You don't need to add recitation, labs, or lectures seperately, it does that for you.
*You may need to reload the page to get results*
{% endblock %}


Assuming that all of the monthly payments are the same, Fernando will need to pay


Second runway may not materialise
ILS enables landing from both sides of existing runway
by Staff ReporterNotwithstanding the provision for a second runway in the original blueprint of Cochin International Airport Limited (CIAL), it may not be forthcoming any time soon owing to operational and logistical reasons.
A second runway was proposed along the northern side from the very outset, when the airport was proposed. However, it was kept in abeyance in the face of logistical hiccups and resistance involved in land acquisition.
So, rather than delaying the project for a second runway, which was superfluous for a nascent airport, the board of directors of the airport company decided to go ahead with a single runway.
Though the airport has completed over two decades of operations, CIAL sources said a second runway remained far from imminent by comparing aircraft handling statistics of the Kochi airport with the one in Mumbai, the busiest in the world with single runway operations.
Mumbai airport
For instance, last year, the Mumbai airport broke its own record multiple times before breaching the benchmark of 1,000 flights a day in December.
It handled 1,004 flights on that day that included 903 scheduled flights, 59 non-scheduled flights, eight charter flights, 31 freighter movements and three military operations.
“Compared to that, the Kochi airport still handles only 240 services a day, which means it can continue to operate with a single runway even after a four-fold increase in flights from what is now,” said CIAL sources.
New system
Besides, it is also pointed out that at least technically, the airport has two runways now with the induction of an Instrumental Landing System (ILS) a year ago that facilitates landing from both sides of the existing runway. Initially, the landing was possible along the eastern side of the runway while the induction of the ILS has now made landing possible from the western side as well.
The complications of land acquisition also make the proposal for a second runway less attractive.
The Kochi airport may need 400 to 500 acres of land if it plans for a second runway.


Tweetcloud
a Twitter Livestream visualization
by Michael Hazani
search the Zeitgeist for:
Begin Stream
Stop Stream
Destroy Cloud
Tumblr
//
Github
Click+drag to change angle
Scroll to zoom
Escape to quit


ZIKV strains African indicated Zika strain Asian Vero Asian-lineage infection {border-style virus px;} #ffffff;} Virus []. compared higher African-lineage Biology cell Sciences led strains. Cell differences Asian: Life cells human lineage studies viral Aedes African: death Uganda data early neural px; showed virulence {font-family Negl Senegal Trop epidemic font-size rate recent study Dis. Health Human Pathogens aegypti cause double; edoi: infections neurological stronger symptoms vivo (Table ./journal.pntd. Brazil C/, However, Infection MR, Viral al.A al.Zika antiviral associated border-color border-width congenital induced induction isolated original production response solid; strains, {font-style {font-weight Flaviviruses: H/PF/ MR; Medicine Microbiology Neural PRVABC Puerto Unknown Vectors available bold courier; em; infection. inflammatory mice microcephaly pt;} severe stem transmission


Pymanopt is a Python toolbox for optimization on manifolds, that computes gradients and Hessians automatically. It builds upon the Matlab toolbox Manopt but is otherwise independent of it. Pymanopt aims to lower the barriers for users wishing to use state of the art techniques for optimization on manifolds, by relying on automatic differentiation for computing gradients and Hessians, saving users time and saving them from potential calculation and implementiation errors.
Pymanopt is modular and hence easy to use. All of the automatic differentiation is done behind the scenes, so that the amount of setup the user needs to do is minimal. Usually only the following steps are required:
Experimenting with optimization on manifolds is simple with Pymanopt. The minimum working example below demonstrates this. The steps will be discussed in more detail in the subsequent three sections. Please refer to this example for a cool application of Riemannian optimization using Pymanopt for Inference in MoG models!
We encourage users and developers to report problems, request features, ask for help, or leave general comments either on github, gitter, or via email to one of the maintainers. Please refer to the dev documentation and the CONTRIBUTING.md file if you wish to extend Pymanopt's functionality and/or contribute to the project. Pymanopt is distributed under the open source 3-clause BSD license. Please cite this JMLR paper if you publish work using Pymanopt (BibTeX).
import autograd.numpy as np
from pymanopt.manifolds import Stiefel
from pymanopt import Problem
from pymanopt.solvers import SteepestDescent
# (1) Instantiate a manifold
manifold = Stiefel(5, 2)
# (2) Define the cost function (here using autograd.numpy)
def cost(X): return np.sum(X)
problem = Problem(manifold=manifold, cost=cost)
# (3) Instantiate a Pymanopt solver
solver = SteepestDescent()
# let Pymanopt do the rest
Xopt = solver.solve(problem)
print(Xopt)
Pymanopt is compatible with Python 2.7 and Python 3.4+, and depends on NumPy and SciPy. Additionally, to use Pymanopt's built-in automatic differentiation, which we strongly recommend, you need to setup your cost functions using either Autograd, Theano or TensorFlow. If you're unfamiliar with these packages and not sure which to go for, it's probably best to start with Autograd. Autograd wraps thinly around NumPy, and is very simple to use, particularly if you're already familiar with NumPy (see below).
Instructions for installing NumPy, SciPy, and Theano on different operating systems can be found here, for installing Autograd here and for installing TensorFlow here.
Pymanopt can be installed with the following command:
pip install --user pymanopt
The rigorous mathematical definition of manifold is abstract and too technical for this tutorial. However if you're unfamiliar with the idea, it's fine just to visualize it as a smooth subset of Euclidean space. Simple examples include the surface of a sphere or of a torus, or the Möbius strip. If you need to solve an optimization problem with a search space which is constrained in some smooth way, then performing optimization on manifolds may well be the natural approach to take.
The manifolds that we currently support are listed below. We plan to implement more depending on the needs of users, so if there's a particular manifold you'd like to optimize over, please let us know. If you wish to implement your own manifold for Pymanopt, you will need to inherit from the Manifold abstract base class.
Euclidean(n1, n2, ..., nk)
(n1, n2, ..., nk)
tensors.
Useful for unconstrained problems or for unconstrained hyperparameters,
as part of a product manifold.
from pymanopt.manifolds import Euclidean
# Space of shape (3, ) vectors
manifold = Euclidean(3)
# Space of (4 x 2) matrices
manifold = Euclidean(4, 2)
Symmetric(n, k=1)
(k, n, n)
.
from pymanopt.manifolds import Symmetric
# Manifold of 3 x 3 symmetric matrices
manifold = Symmetric(3)
Sphere(n1, n2, ..., nk)
(n1, n2, ..., nk)
tensors with unit
2-norm.
from pymanopt.manifolds import Sphere
# The 'usual' sphere S^2, the set of points lying
# on the surface of a ball in 3D space:
manifold = Sphere(3)
ComplexCircle(n)
from pymanopt.manifolds import ComplexCircle
manifold = ComplexCircle(3)
Rotations(n, k=1)
from pymanopt.manifolds import Rotations
# Manifold of 3 x 3 orthogonal matrices with
# determinant 1.
manifold = Rotations(3)
Stiefel(n, p, k=1)
from pymanopt.manifolds import Stiefel
# Manifold of 3 x 2 matrices with orthonormal
# columns.
manifold = Stiefel(3, 2)
Grassmann(n, p, k=1)
Manifold of $p$-dimensional subspaces of $\mathbb{R}^n$,
denoted $\mathrm{Gr}(n, p)$. If the optional argument $k > 1$, instantiates
the product $\mathrm{Gr}(n, p)^k$ of $k$ Grassmann manifolds.
If $k = 1$ then elements (subspaces) are represented by $n \times p$ Stiefel
matrices whose columns span the subspace (see above for definition).
If $k > 1$ then elements are represented by a $k \times n \times p$ array
containing $k$ copies of $n \times p$ Stiefel matrices.
from pymanopt.manifolds import Grassmann
# Manifold of planes through the origin in R^3
manifold = Grassmann(3, 2)
Oblique(m, n)
from pymanopt.manifolds import Oblique
# Two 3-vectors, each with norm 1
manifold = Oblique(3, 2)
PositiveDefinite(n, k=1)
(k, n, n)
. This is useful
in the Mixture of Gaussians example.
from pymanopt.manifolds import PositiveDefinite
# Manifold of 3 x 3 positive-definite matrices
manifold = PositiveDefinite(3)
Elliptope(n, k)
from pymanopt.manifolds import Elliptope
# Manifold of 3 x 3 correlation matrices
# of rank 2
manifold = Elliptope(3, 2)
PSDFixedRank(n, k)
PSDFixedRankComplex(n, k)
from pymanopt.manifolds import PSDFixedRank, PSDFixedRankComplex
# 3 x 3 rank 2 p.s.d. matrices
# Real
manifold = PSDFixedRank(3, 2)
# Complex
manifold = PSDFixedRankComplex(3, 2)
FixedRankEmbedded(m, n, k)
from pymanopt.manifolds import FixedRankEmbedded
# 5 x 4 rank 2 matrices
manifold = FixedRankEmbedded(5, 4, 2)
Product((man1, man2, ..., manN))
from pymanopt.manifolds import Product, Stiefel, Euclidean
# Product of Euclidean 3-vector with
# 5 x 2 Stiefel manifold.
manifold = Product((Euclidean(3), Stiefel(5, 2)))
Together, a manifold and cost function fully describe a manifold optimization problem that is to be solved. They are combined into a Pymanopt Problem object that is then passed to a Pymanopt solver.
from pymanopt import Problem
problem = Problem(manifold=manifold, cost=cost)
The cost function passed to Pymanopt should take a single input (a point on the manifold), and return a scalar. You have three options for how to define the cost function:
| Method | Additional requirements | |
|---|---|---|
| (a) | Use Autograd | None |
| (b) | Use Theano | None |
| (c) | Use TensorFlow | None |
| (d) | Use a regular Python function | Calculate and implement derivatives (gradient and Hessian) by hand. |
The first three options are recommended – indeed, they are what makes manifold optimization with Pymanopt so easy!
Currently Pymanopt supports Autograd, Theano and TensorFlow as autodiff backends.
If you already know how to use NumPy, then this approach will be easy. Just import autograd.numpy and setup your cost as a Python function, using the autograd numpy to perform the computation.
import autograd.numpy as np
def cost(X):
return np.exp(-np.sum(X**2))
problem = Problem(manifold=manifold, cost=cost)
This approach requires you to setup your cost as a Theano graph. A tutorial on using Theano can be found here.
import theano.tensor as T
X = T.matrix()
cost = T.exp(-T.sum(X**2))
problem = Problem(manifold=manifold, cost=cost, arg=X)
This approach requires you to setup your cost as a TensorFlow graph. A tutorial on using TensorFlow can be found here.
import tensorflow as tf
import numpy as np
X = tf.Variable(tf.placeholder(tf.float32))
cost = tf.exp(-tf.reduce_sum(tf.square(X)))
problem = Problem(manifold=manifold, cost=cost, arg=X)
If you wish to use one of the derivative-free solvers (perhaps your cost function is nowhere smooth), then this approach makes sense. If you want to use a solver which requires derivatives (these solvers generally perform far better than derivative-free methods) this approach enables you to calculate and implement gradients and Hessians by hand.
Using Pymanopt in this way is similar to Manopt. You can refer to the Manopt tutorial and forum for advice on calculating gradients/hessians by hand. However, we would like to stress that there is little or no advantage to doing things in this way. The gradients and Hessians calculated by Pymanopt should be both correct and efficient.
problem = Problem(manifold=manifold, cost=cost, egrad=egrad, ehess=ehess)
The Pymanopt Solver classes provide the algorithms for optimization. Once a Pymanopt Problem object has been set up and a solver instantiated the optimization is run as follows:
xoptimal = solver.solve(problem)
The solvers' parameters are specified when instantiating the solver object.
The following parameters are shared by all solvers
(argumentname=defaultvalue
):
maxtime=1000
maxtime=float('inf')
for no time limit.maxiter=1000
mingradnorm=1e-6
minstepsize=1e-10
maxcostvals=5000
logverbosity=0
xoptimal = solver.solve(problem, logverbosity=0)
xoptimal, optlog = solver.solve(problem, logverbosity=2)
See below for a minimalistic example.The solvers implemented in Pymanopt are listed below. Note, all of these are currently based on solvers from Manopt, and more details may be found on the Manopt website. Solvers may have individual parameters to adjust their behaviour. These are documented in the respective source files. If you wish to implement your own solver, you must inherit from the Solver abstract base class. The steepest_descent solver is reasonably simple and could be used as a model for custom solvers.
TrustRegions()
from pymanopt.solvers import TrustRegions
solver = TrustRegions()
Xopt = solver.solve(problem)
SteepestDescent()
linesearch
parameter:
SteepestDescent(linesearch=LinesearchObject)
.
You can also implement your own linesearch class, just take
this code
as a starting point.
from pymanopt.solvers import SteepestDescent
solver = SteepestDescent()
Xopt = solver.solve(problem)
ConjugateGradient()
linesearch
parameter:
ConjugateGradient(linesearch=LinesearchObject)
.
You can also implement your own linesearch class, just take
this code
as a starting point.
from pymanopt.solvers import ConjugateGradient
solver = ConjugateGradient()
Xopt = solver.solve(problem)
NelderMead()
from pymanopt.solvers import NelderMead
solver = NelderMead()
Xopt = solver.solve(problem)
ParticleSwarm()
from pymanopt.solvers import ParticleSwarm
solver = ParticleSwarm()
Xopt = solver.solve(problem)
Several examples that demonstrate how to use Pymanopt can be found here. Below are some examples that demonstrate certain use-cases that may be of general interest and give an idea of what can be done with Pymanopt.
| Example | Notes | Links |
|---|---|---|
| Log optimization behaviour | Demonstrates how to log and inspect the optimization behaviour, i.e. how the cost function's value changes over iterations, which of the stopping criterions caused the solver to stop, etc. | optlog_example.py |
| Riemannian optimization using Pymanopt for Inference in MoG models | Given samples of a Mixture of Gaussians model, infer the parameters using optimization on manifolds instead of expectation maximisation (EM). | MoG.html / MoG.ipynb |
| Linear regression as optimization over the product manifold | Optimises the weights $w$ and the offset $b$ in the linear regression problem $\min_{w,b} ||Y-w^\top X-b||_2^2$, for given label vector $Y$ and covariates matrix $X$ over the product manifold $\mathbb{R}^3 \times \mathbb{R}$ to demonstrate optimization over product manifolds. | regression_offset_autograd.py / regression_offset_theano.py / regression_offset_tensorflow.py |
| Solve the same optimization problems for several data instances | Demonstrates how to solve the same optimization problems for several data instances, i.e., in this case solving a regression problem for five different datasets. | linreg_multiple_autograd.py / linreg_multiple_theano.py |


--- title: A GWT Wizard Widget for Your Project permalink: /index.html --- GWT-Wizard is a wizard widget for your project. See the README.md file for general information. The tutorial provides a great starting point for learning to use GWT-Wizard (please note that this tutorial is still under heavy construction):


Eloise McIntyre - Software Development
Technical Blog - A Space Where My Technical Developments Can Be Shared!
“Perfect is the enemy of good.” –Voltaire
HOME
BLOG
TECHNICAL
Sprint 2 Tech Blog - 12th Sept 2019 --
What is the best practice for using classes and ID's?
Sprint 3 Tech Blog - 22th Sept 2019 --
JavaScript, The DOM, and DevTools --
Sprint 4 Tech Blog - 26th Sept 2019 --
Problem Solving --


Highest Score: 5/5
The Coding Quiz Challenge
You have 1 minute to complete 5 questions. Are you ready?
1:00
Click to Begin
Your Score:
Submit


jQuery’s mobile strategy can be summarized simply: A unified user interface system that works seamlessly across all popular mobile device platforms, built on the rock-solid jQuery and jQuery UI foundation. Focused on a feature-rich but lightweight codebase built on progressive enhancement with a flexible, theming system and ThemeRoller tool.
The framework includes an Ajax navigation system that brings animated page transitions and a core set of UI widgets: pages, dialogs, toolbars, listviews, buttons with icons, form elements, accordions, collapsibles, and more.
The critical difference with our approach is the wide variety of mobile platforms we’re targeting with jQuery Mobile so no browser or device is left behind. We've also focused on making jQuery Mobile easy to learn with a simple, markup-based system to applying behavior and theming. For more advanced developers, there is a rich API of global configuration options, events, and methods to apply scripting, generate dynamic pages, and even build native apps with tools like PhoneGap.
To make this broad support possible, all pages in jQuery Mobile are built on a foundation of clean, semantic HTML to ensure compatibility with pretty much any web-enabled device. In devices that interpret CSS and JavaScript, jQuery Mobile applies progressive enhancement techniques to unobtrusively transform the semantic page into a rich, interactive experience that leverages the power of jQuery and CSS. Accessibility features such as WAI-ARIA are tightly integrated throughout the framework to provide support for screen readers and other assistive technologies.


1.2 RStudio projects
RStudio projects (.Rproj
) are a handy solution to keep all the files related to a specific workflow, including
- R scripts (
.R
), - workspace (
.RData
), - history (
.Rhistory
), - datasets,
- etc.,
together in one working directory. RStudio projects, once opened, are automatically associated with the directory the .Rproj
file is located in, thus rendering unnecessary the use of setwd()
.
Starting a new project
From inside RStudio, projects are easily initialized and associated with either
- a brand new working directory,
- an existing directory or
- a local copy of a version control repository (of which more later on)
by hitting the ‘New Project…’ button from the drop-down menu at the top-right corner.
Working with projects
Once created, RStudio automatically switches to the new project (not without asking if you’d like to safe your latest changes, of course). If you desire to work with an already existing project instead, you may simply open the referring .Rproj
file either via the drop-down menu in the top-right corner, or just double-click it within your system’s file explorer. Note that, among others, the following actions are taken when a project opens inside RStudio (taken directly from the RStudio Support Team:
- a new R session is started;
- the
.Rprofile
in the project’s main directory (if any) is sourced; - the recent workspace stored in
.RData
in the project’s main directory is loaded (if indicated by the project options); - the
.Rhistory
file in the project’s main directory is loaded into the RStudio ‘History’ pane and available for console up/down arrow command history; - previously edited source documents are restored into editor tabs.
Similarly, when you quit a project,
- the
.RData
and.Rhistory
are being saved (if indicated by the project options); - the currently active R scripts are being saved;
- the current R session is terminated.
Task: Create your own RStudio project
Now it’s your turn: Initialize a new RStudio project in the advanced-programming-in-r
subfolder from Section 1.1, i.e. the one with Git version control enabled! For that purpose,
- choose an existing directory rather than a new one and
- navigate to the
advanced-programming-in-r
subfolder that you have copied from GitHub earlier usinggit clone
.
After having accomplished this,
git add
all the stuff that has accumulated in the local project directory so far (mostly.Rproj
related files)- followed by
git commit
(including a meaningful description of your recent actions) - and, finally,
git push
.
It is totally up to you whether to use the built-in RStudio interface to be found in the top-right ‘Git’ pane or run git
from the command line. Due to its ease of use, I highly encourage you to choose option #1, though.
To verify that everything worked as expected, head over to the web-based representation of your code repository on GitHub. In addition, don’t forget that you may use git status
at any stage to get further information on the status quo of the Git processing chain. There’s also a comprehensive tutorial on version control with Git (and SVN) on the RStudio support website if you wish to gather further insights into the topic.


Booking
This is div1
This is div2
This is a span
This is another span
Tabel hoteluri
Name
Address
City
Site
Rooms
Stars
Unirea
Piata Unirii
Iasi
Hotel Unirea website
250
4
Traian
Piata Unirii
Iasi
Hotel Traian website
200
3
Add
Search
Last minute deals
City:
Check-in:
Check-out:
Hotel name:
Hotel picture:
Discount


- SearchCLI - Class in personal.darius.search
-
This class will handle all of the search functionality in the FindMusic program and will
present information as a CLI
- SearchCLI(String[]) - Constructor for class personal.darius.search.SearchCLI
-
Search constructor that will be used for the CLI
- SearchCLITest - Class in personal.darius.search
-
Tests the SearchCLI methods
- SearchCLITest() - Constructor for class personal.darius.search.SearchCLITest
-
- searchForRelease(String, String) - Method in class personal.darius.search.SearchCLI
-
Searches a website using an artist's name and current date as parameters to find new music
released by the artist for that day
- searchForRelease(String, String, Stage) - Method in class personal.darius.search.SearchGUI
-
Searches a website using an artist's name and current date as parameters to find new music
released by the artist for that day
- SearchGUI - Class in personal.darius.search
-
This class will handle all of the search functionality in the FindMusic program and will display
a GUI
- SearchGUI() - Constructor for class personal.darius.search.SearchGUI
-
- SearchGUITest - Class in personal.darius.search
-
Tests the SearchGUI methods
- SearchGUITest() - Constructor for class personal.darius.search.SearchGUITest
-
- set(int, E) - Method in class personal.darius.dataStructures.ArrayList
-
Replaces the item at the index with the item passed in as a parameter
- setReleaseDate(String) - Method in class personal.darius.data.Song
-
Sets the releaseDate field
- setup() - Method in class personal.darius.search.SearchGUITest
-
Prior to each test, the GUI is started from scratch
- setupCLI(String[]) - Method in class personal.darius.search.SearchCLI
-
Initializes the command line interface
- size() - Method in class personal.darius.dataStructures.ArrayList
-
Getter method for the size instance variable
- Song - Class in personal.darius.data
-
The song class is the base class of the entire project.
- Song(String, String) - Constructor for class personal.darius.data.Song
-
Creates a new Song object that contains a song title and artist
- SongStorage - Class in personal.darius.database
-
- SongStorage() - Constructor for class personal.darius.database.SongStorage
-
- SongTest - Class in personal.darius.data
-
Tests the Song class and its methods
- SongTest() - Constructor for class personal.darius.data.SongTest
-
- Sorter<E> - Class in personal.darius.sort
-
The Sorter Class handles all of the sorting for the program
- Sorter() - Constructor for class personal.darius.sort.Sorter
-
Creates a Sorter object
- SorterTest - Class in personal.darius.sort
-
Tests the Sorter class and its methods
- SorterTest() - Constructor for class personal.darius.sort.SorterTest
-
- start(Stage) - Method in class personal.darius.search.SearchGUI
-
The starting point for the GUI


Gossip
Profile
Find user
Decrypt
Search Phoenix.com
Search
3
Results for
"Bob"
Bob
Joined July 11, 2014
16 followers
Bobby Nintendo
Joined June 6, 2014
0 followers
Alice Bobberson
Joined August 18, 2014
2 followers
1 mutual


Butchering Farmer John's cows always yields the best prime rib. You can tell prime ribs by looking at the digits lovingly stamped across them, one by one, by FJ and the USDA. Farmer John ensures that a purchaser of his prime ribs gets really prime ribs because when sliced from the right, the numbers on the ribs continue to stay prime right down to the last rib, e.g.:
7 3 3 1
The set of ribs denoted by 7331 is prime; the three ribs 733 are prime; the two ribs 73 are prime, and, of course, the last rib, 7, is prime. The number 7331 is called a superprime of length 4.
Write a program that accepts a number N 1 <=N<=8 of ribs and prints all the superprimes of that length.
The number 1 (by itself) is not a prime number.
4
2333 2339 2393 2399 2939 3119 3137 3733 3739 3793 3797 5939 7193 7331 7333 7393


Home > JavaScript Questions > Determine the output of following code on console ?
1. var x = 1;
2. function outer(){
3. var y = 2;
4. x++;
5. function inner(){
6. x++;
7. y++;
8. console.log(x,y);
9. }
10. return inner;
11. }
12. var innerFun = outer();
13. innerFun();
14. outer();
15. innerFun();
1. If we take a close look to the code then we will see that after calling outer function at line 12 we store the function reference of inner() to the innerFun variable via calling the outer() function that is we are of JavaScript language which actually moving the scope of inner() function to the global context.
2. After executing line 12 inner function refernce gets stored in the innerFun variable and var x will increased to 2 .
3. At line 13 calling inner function via innerFun variable it actually increase the var x and var y to 3,3 respectively. It will create a execution stack where now x=3,y=3 will be stored.
4. At line 14 we again call the outer function which will create the separate exection stack which is different from created in line 12. Here in current execution stack x=4,y=2.
5. At line again we are calling inner function via previous execution stack where x=3,y=3 but due to again calling outer function at line 14 x=4 due to its global scope.Till now x=4,y=3 Now if we again call inner() at line 15 then x=5, y=4.


{% extends 'common/base.html' %} {% block head_title %}Units{% endblock %} {% block main_content %}
Pets: Helpful Pals
Dogs: Barking Buddies
Cats: Purring Pets
Birds: Flying Pets
Fish: Water Pets


Contents:
CEDRIC is a FORTRAN application for the analysis of gridded radar data, and this is a python wrapper to some of the core functionality of CEDRIC.
By separating the CEDRIC code into a library archive and a main application, both the application and the python module can be built by linking to the same library. The library modules must be built as position-independent code (PIC) to allow them to be linked into the sharable python module.
The basic CEDRIC library is built without NCAR Graphics enabled, since that is the most reasonable form to embed in the python wrapper or in custom applications. The CEDRIC application which supports NCAR Graphics (gcedric) is built by recompiling a few of the graphics-dependent modules separately from the library. These modules are linked to the gcedric application before the non-graphical library, thus the graphical implementations override the non-graphical routines in the library.
The python interface to the FORTRAN code is generated with the f2py tool of the numpy package. The interface definition file (_cedric.pyf) is generated from several FORTRAN routines, including these modules used without change, mostly to support reading the CEDRIC binary file format:
- VERSOUT.F
- SYMINT.F
- CEDINIT.F
- CEDQUIT.F
- READVL.F
- FETCHD.F
- SETVOL.F
- STATS.F
In addition, the CEDRIC library now includes rewrites of several core computational routines. Xiaowen Tang adapted these modules for the python interface. In particular, these modules have been updated to use newer FORTRAN 90 syntax and features, and they handle an entire 3D field array instead of processing only one level at a time:
- BNDFIL.F90
- CALUVW3d.F90
- DWITER.F90
- INTGRT3d.F90
- PCONVGP.F90
- ms3d.f90
f2py builds the _cedric.so dynamically-loaded python module using the _cedric.pyf interface file and linking to the CEDRIC library. The _cedric.so python module is a private module inside the cedric python package. The cedric package is meant to provide a more convenient python API to the underlying f2py interfaces.
The cedric package encapsulates the CEDRIC library wrapper code and some convenient python methods for accessing and processing CEDRIC data.
Of particular importance is the ability to read CEDRIC binary files through the original FORTRAN code. This means the python package should be able to access all the same data files as the CEDRIC application with complete compatibility, since the FORTRAN code handles all of the byte order, swapping, or special cases in the decoding the file format.
Xiaowen Tang has also started extending the CEDRIC functionality with python implementations. For example, the cedric.algorithms module provides the vt_correction method for doing fall speed correction on the synthesized wind field. The cedric.plots module provides convenience methods for plotting radar fields with the matplotlib package.
The main interface to the cedric package is defined in the __init__.py module. This module provides simple entry points to the CEDRIC library implementations. It also integrates a high-level data structure called the Volume class, defined in the cedric.file module. The Volume class encapsulates the metadata and data contained through the CEDRIC volume block. It contains the data for all of the radar fields, stored as numpy arrays, and indexed by field name in the Volume object. The fields themselves are actually Variable instances. The Variable instance can be indexed like any numpy array, but it retains the radar metadata like field name and the indexing levels. So far this feature is primarily used by the cedric.plots utilities to generate reasonable titles and axis names.
The documentation for the python API is generated automatically here: CEDRIC Python API.


I robo-ed for the first time in months this weekend. Did more than I ever had before, here's the story:
8:15 pm: Friend and I each take 5 Robitussin cough caps, and rinse them down with 4 oz of Robo DM syrup. Taste is worse than I remember.  Stomach is a little bit uncomfortable. Friend says she feels a little nauseous also. We ate before hand, so the stomach discomfort was not as bad as before.
8:45ish: Very light headed. Tracers begin showing up on just about everything. We get to another friends house, and sit down to watch tv.
9:00 : Seriously feeling effect. Head spinning slighty, not bad. Stomach discomfort gone. Limbs feel unconnected to body. I notice that I have been watching tv for 15 minutes, and have no idea what I am watching.  I find it very hard to concentrate on anything for more than about a second. Music, which I normally get into, I can't really listen to. Repeated attemps at conversation fail because I can't remember what I am saying as I say it. total inability to grasp concept of time. A friend's sentence take forever to finsh, and I completely forget what is said as soon as he is done. When I close my eyes, all sorts of incredible hallucinations kick in. When my eyes are open, I see everything as normal, but have NO idea what I'm looking at.
10:30ish Friend gets pizza. I am totally unable to eat. Wierd, seeing as how often I get the munchies. I can no longer move my head without totally losing contact with reality. As long as I am talking, I'm fine. Time flies and crawls at the same time. Truely wierd.
Evening progresses until I have to leave(couldn't take beeing on that couch any longer)
Midnight: Go back to friends house. Have to catch a ride because I am TOTALLY unable to operate an automobile, assuming I had driven in the first place. Lye down on floor. Carpet, which is normally uncomfortable, is quite nice right now.   It is suddenly half an hour later.  Normally about a mile, I can walk it in 15 minutes if I really take my time. As I walk, I realize that I don't feel connected to my legs, I'm just 'floating' along, above the ground. I feel as if I'm going to fall any minute, but never do. I make it home, and down the stairs into my room. I make it into my bed, where I close my eyes, and trip out for another three hours, when my phone rings, and I end up explaining how to use Tlenet to one of my friends. After a rather lengthy conversation, I slip into unconsciousness completely.
Next day: I am still totally out to lunch, and am still unable to grasp time. Things just fly by unnoticed. Kinda cool, kinda strange. I like it, but it better be gone by tommorow.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


This is Present-It
A Slide Deck built with Web Components
You can change the color of the slide!
background-color="#ff0000"
Can even do rgb/rgba
background-color="rgb(20,122,12)"
This slide has the class has-light-background
Color contrast can be checked
### you can even have markdown!
- item one
- item two
- item three
And code, we got the best code
class HelloWorld extends HTMLElement {
constructor() {
super();
}
connectedCallback() {
this.init();
}
init() {
this.innerHTML = `<h1>Hello World</h1>`
}
}
window.customElements.define('hello-world', HelloWolrd);
Fragment
Hello1
Hello2
Hello3
Hello4
Dynamic color
</html>


I'm a project manager and general tech enthusiast pursuing a career in web development. When I'm not working on a coding project you can usually find me gaming, jogging or cooking (poorly). Coding is my attempt to fulfill my love of solving puzzles and problems. My strength is in coding logic but I also enjoy the feeling of accomplishment that comes with deploying an app to the web. If you think I can help you out, let me know.


Established in 2014, Naachimaar Exports is a reckoned business entity making available a wide range of products in the global markets. Situated in Karur, Tamil Nadu, the company has spread its arms in almost all parts of the globe. Under the proficient headship of the honourable proprietor, N Gowtham, the company has been scaling new heights of success in all its business endeavours. Owing to his vast experience, we are capable of catering to the exact expectations of the clients
We have advanced facilities for storage, processing and packaging of the assorted products that we deal in. Besides the facilities our team is the key strength. We are assisted by a team of professionals who are well versed with the demands of the clients and procure the best quality from the most dependable vendors. Further our team comprises professionals from various domains including marketing, quality assurance etc. Hence we ensure delivery of only flawless products.
Quality is the maker concern of our company. Hence to ensure the best quality, we conduct stringent tests and checks on all the products following strict quality regulations. All the checks are conducted under the supervision of our quality control executives. This enables us to deliver premium products to the clients, meeting their diverse requirements.
We have expanded our base in different parts of the world. Our network base is largely based out of Sharjah, Singapore and U.K. We aspire to satisfy clients to the fullest. Thus, we make efficient and time bound delivery with the support of our well connected network.


Invoice
Your invoice details are given bellow.
Invoice To
Invoice
- Invoice ID:
- Date:
| Item ID | Description | Price |
|---|---|---|
| 1 | ||
| 2 | Service | $0 |
| Total | $478.50 |
Invoice was created on a computer and is valid without the signature and seal.


Point Grey areaDetector driver¶
Point Grey areaDetector driver
July 21, 2017
Mark Rivers
University of Chicago
Table of Contents¶
Introduction¶
This is an EPICS areaDetector driver for cameras from Point Grey. These include IEEE 1394 Firewire DCAM, GigE, USB 2.0, and USB 3.0 cameras. The driver should work with any Point Grey camera. It has been tested on Firewire (Flea2), GigE (BlackFly, Flea3, Grasshopper3), and USB 3.0 (Grasshopper3) cameras. The driver has been tested on Windows and Linux with all 3 of these cameras. Note that Point Grey Firewire cameras can also be controlled by the generic areaDetector Windows Firewire driver and the areaDetector Linux Firewire driver, which work with Firewire cameras from any vendor. However, this Point Grey driver provides access to some vendor-specific features like strobe outputs that are not available in the generic drivers.
On Linux the Point Grey FlyCap2 SDK requires glibc version 2.14. This means it cannot be used on RHEL 6, but it can be used on RHEL 7, and Fedora 15 and higher. For USB 3.0 cameras kernel version 3.5.0 or higher is required. This means USB 3.0 cameras require Fedora 18 or higher, or RHEL 7.0 or higher.
This driver inherits from ADDriver. It implements many of the parameters in asynNDArrayDriver.h and in ADArrayDriver.h. It also implements a number of parameters that are specific to the Point Grey cameras. The pointGrey class documentation describes this class in detail.
The Point Grey cameras use the IIDC/DCAM model for controlling features like shutter time, white balance, frame sizes, shutter time, frame rates, etc. This model is used not only for the IEEE 1394 Firewire cameras, for which the IIDC/DCAM model was developed, but also for their USB and GigE cameras. The Point Grey driver thus has many similarities to the generic areaDetector Windows Firewire driver and the areaDetector Linux Firewire driver. The FlyCapture2 SDK abstracts this model to a certain extent, which facilitates writing a driver that works with all of the Point Grey cameras.
Camera firmware¶
Point Grey frequently updates the available firmware for each camera to add features and fix bugs. However, they are not very good about putting the link to the latest firmware on their Web site. They claim this is because they only put the firmware on the Web site once it has been tested on all camera models in the camera family on which that firmware runs. In practice the firmware version listed on the Web site is often old and buggy. I have encouraged them to make the latest firmware more easily available. At present one must e-mail the support team<EMAIL_ADDRESS>and ask them if newer firmware is available for a particular camera, and if so to provide access to it. They normally do this by sending a link to a Dropbox folder.
Video modes¶
The DCAM specification defines standard video formats, and a set of video modes for each video format. Point Grey combines the video format and video mode into a single quantity they call VideoMode. The following table lists these standard video modes.
Video mode Format7 is special. It allows defining an ROI on the camera to read out. The pixel resolution with which the size and position of this ROI can be defined can be queried, and is not necessarily a single pixel. In Format 7 the frame rate settings do not apply, and there is a another setting called PixelFormat that controls the video format, e.g. Mono8, Mono16, RGB8, etc.
Most cameras only support a small subset of these standard modes. The EPICS record $(P)$(R)VideoMode is an mbbo record that only has choices for the video modes actually available on the specific camera in use. Since mbbo records only allow a maximum of 16 choices and there are 24 standard video modes, it is conceivable that all available videos modes would not be presented. In practice this is not a problem since no existing camera supports more than 16 video modes.
Point Grey Video Modes
Mode Number
Mode Description
0
160x120 YUV444
1
320x240 YUV422
2
640x480 YUV411
3
640X480 YUV422
4
640x480 RGB
5
640x480 Mono8
6
640x480 Mono16
7
800x600 YUV422
8
800x600 RGB
9
800x600 Mono8
10
1024x768 YUV422
11
1024x768 RGB
12
1024x768 Mono8
13
800x600 Mono16
14
1024x768 Mono16
15
1280x960 YUV422
16
1280x960 RGB
17
1280x960 Mono8
18
1600x1200 YUV422
19
1600x1200 RGB
20
1600x1200 Mono8
21
1280x960 Mono16
22
1600x1200 Mono16
23
Format7 (user-defined)
Format7 modes¶
When the video mode is Format7 then there is an available selection of Format7 modes. These modes are not defined in the IIDC/DCAM standard, but are specific to each vendor and camera. Typically Format7 mode 0 is the entire chip unbinned, and mode 1 is often the entire chip with 2x2 binning. The supported Format7 modes are listed in the Point Grey Technical Reference Manual for each camera. The EPICS Format7Mode record is used to select the Format7 mode to use. This is an mbbo record and the enum choices are only those supported by the camera in use. The enum strings are of the form “Format7 mode # (NYxNY)”, for example “0 (1920x1200)” or “1 (960x600)” for Format7 modes 0 and 1 respectively on a camera with 1920 x 1200 pixels.
Pixel formats¶
When the video mode is Format7 then there is an available selection of PixelFormats. The available PixelFormats depend on the selected Format7 mode. Selection of a PixelFormat is done with the EPICS PixelFormat record. This is an mbbo record that only has choices that are valid for the currently selected Format7 mode. The enum values in this record are thus dynamic, and it is displayed in a separate GUI window that must be closed and re-opened when the Format7 mode changes in order to guarantee that it is displaying the currently valid PixelFormat choices.
The following tables lists the standard pixel formats for video mode Format7. Note that typically only a few of these pixel formats are supported on a particular camera with a specific Format7 mode.
Point Grey Format7 Pixel Formats
Pixel Format Number
Pixel Format Description
0
Mono8
1
YUV411
2
YUV422
3
YUV444
4
RGB8
5
Mono16
6
RGB16
7
Mono16_Signed
8
RGB16_Signed
9
Raw8
10
Raw16
11
Mono12
12
Raw12
13
BGR
14
BGRU
15
BGR16
16
BGRU16
17
YUV422_JPEG
Frame rates¶
The following tables lists the standard IIDC/DCAM frame rates for video modes other than Format7. Selecting a video mode (other than Format7) defines the choice of available standard frame rates. Selecting a standard frame rate actually defines a range of frame rates that are available, and the actual frame rate can be adjusted within this range with the FrameRate property. The FrameRate property is controlled with the EPICS FrameRateAbsVal or AcquirePeriod records.
Selection of a standard frame rate is done with the EPICS FrameRate record. This is an mbbo record that only has choices that are valid for the currently selected video mode. The enum values in this record are thus dynamic, and it is displayed in a separate GUI window that must be closed and re-opened when the video mode changes in order to guarantee that it is displaying the currently valid FrameRate choices. Note that not all frame rates are supported by the IIDC standard for every video mode, and even when a frame rate is supported by the standard it may not be implemented for a particular camera.
In Format 7 the frame rate settings do not apply, and the frame rate is controlled solely by the FrameRate property.
Standard IIDC/DCAM Video Frame Rates
Frame Rate Number
Frame Rate (Frames/second)
0
1.875
1
3.75
2
7.5
3
15
4
30
5
60
6
120
7
240
Properties¶
The DCAM specification defines a number of standard features, which control things such as the brightness, white balance, shutter time, etc. For each feature the standard defines control in both device units (12-bit integers) and absolute units (floating point). For example shutter time may support absolute seconds, as well as device units. A feature may or may not be supported on a particular camera. If it is supported it may or may not permit control in absolute units. Each feature may support both manual control and automatic control (e.g. automatic gain control).
Point Grey supports 18 of these DCAM features, which they call Properties.
Point Grey Camera Properties
Property Number
EPICS Record Base Name
Point Grey PropertyType enum
0
Brightness
BRIGHTNESS
1
AutoExposure
AUTO_EXPOSURE
2
Sharpness
SHARPNESS
3
WhiteBalance
WHITE_BALANCE
4
Hue
HUE
5
Saturation =
SATURATION
6
Gamma
GAMMA
7
Iris
IRIS
8
Focus
FOCUS
9
Zoom
ZOOM
10
Pan
PAN
11
Tilt
TILT
12
Shutter
SHUTTER
13
Gain
GAIN
14
TriggerMode
TRIGGER_MODE
15
TriggerDelay
TRIGGER_DELAY
16
FrameRate
FRAME_RATE
17
Temperature
TEMPERATURE
GigE Properties¶
Point Grey supports 4 properties that are specific to GigE cameras.
Point Grey Camera Properties
Property Number
EPICS Record Base Name
Point Grey PropertyType enum
0
Heeartbeat
HEARTBEAT
1
HeartbeatTimeout
HEARTBEAT_TIMEOUT
2
PacketSize
PACKET_SIZE
3
PacketDelay
PACKET_DELAY
Standard areaDetector parameters¶
The following table describes how the Point Grey driver implements some of the standard driver parameters.
Implementation of Parameters in asynNDArrayDriver.h and ADDriver.h, and EPICS Record Definitions in ADBase.template and NDFile.template
Parameter index variable
EPICS record name
Description
ADTriggerMode
$(P)$(R)TriggerMode
The choices for the Point Grey are:
- “Internal”. The timing is internal to the detector.
- “Ext. standard”. Each external trigger pulse starts the next image. The exposure time is controlled internally by the AcquireTime record.
- “Bulb”. The rising edge of the external trigger signal starts the next image. The detector continues to acquire while the external signal is high, and then reads out the detector on the falling edge of the external trigger signal.
- “Skip frames”. One external trigger pulse starts an image and then the next N external trigger signals are ignored. The SkipFrames record defines N.
- “Multi-exposure”. One external trigger pulse starts an image and then the next N-1 external trigger signals cause an additional exposure into the same image. The image is read out after trigger N. The NumExposures record defines N.
- “Multi-exposure bulb”. A combination of bulb and multi-exposure modes above. N exposures are accumulated into an image before it is read out. The time in the logic high state determines the acquire time for each exposure. The NumExposures record defines N.
- “Low-smear”. Smear reduction works by increasing the speed of the vertical clock near the end of the integration cycle. See the Technical Reference Manual for the camera for more information.
- “Multi-shot”. A single external trigger causes N images to be acquired. The NumImages record defines N. NumImages is limited to a maximum 255 in this mode.
Note that the minimum time between external trigger pulses is no more than the maximum value of FrameRate in the current mode, and may be less for a particular camera. Note also that not all cameras support all TriggerModes. The TriggerMode enum string choices are only those supported for the camera in use.
ADTemperatureActual
$(P)$(R)TemperatureActual
The readback of the temperature.
ADNumImages
$(P)$(R)NumImages
Controls the number of images to acquire. When TriggerMode=Internal this is handled in software. When TriggerMode=Multi-shot it is handled in the camera firmware.
ADNumExposures
$(P)$(R)NumExposures
Controls the number of exposures per image when TriggerMode=”Multi-exposure” or “Multi-exposure bulb”.
ADAcquireTime
$(P)$(R)AcquireTime
Controls the acquisition time per image. This is converted into the ShutterAbsVal control of the SHUTTER property. ShutterAbsVal = AcquireTime*1000., because SHUTTER units are ms.
ADAcquirePeriod
$(P)$(R)AcquirePeriod
Controls the period between images. This is converted into the FrameRateAbsVal control of the FRAME_RATE property. FrameRateAbsVal = 1./AcquirePeriod.
ADGain
$(P)$(R)Gain
Controls the analog gain on the camera. This is converted into the GainAbsVal control of the GAIN property. The units are dB.
Point Grey specific driver parameters¶
The Point Grey driver implements the following parameters in addition to those in asynNDArrayDriver.h and ADDriver.h. The database file is pointGrey.template for all records except the property records, which are in pointGreyProperty.template.
Parameter Definitions in firewireWinDCAM.cpp and EPICS Record Definitions
Parameter index variable
asyn interface
Access
Description
drvInfo string
EPICS record name
EPICS record type
Video mode parameters
PGVideoMode
asynInt32
r/w
The video mode. All possible values are listed in the Video modes section above. The actual enum choices for this record will only include the video modes supported by the camera in use.
PG_VIDEO_MODE
PGFormat7Mode
asynInt32
r/w
The Format7 mode when the camera is in VideoMode=Format7. This is discussed in the Format7 modes section above. The actual enum choices for this record will only include the Format7 modes supported by the camera in use.
PG_FORMAT7_MODE
PGPixelFormat
asynInt32
r/w
The pixel format when the camera is in VideoMode=Format7. This is discussed in the Pixel formats section above. The actual enum choices for this record will only include the pixel formats supported by the camera in use for the Format7Mode currently selected.
PG_PIXEL_FORMAT
PGConvertPixelFormat
asynInt32
r/w
The driver allows converting the pixel format from the camera to another pixel format. The pixel formats from the camera that can be converted are:
- Raw8
- Raw12
- Raw16
- Mono12
The pixel format that these can be converted to are:
- None: The input pixel format is not converted.
- Mono8: The input pixel format is converted to Mono8.
- Raw16: The input pixel format is converted to Raw16. This is useful when the input pixel format is Raw12, since this saves network bandwidth.
- Mono16: The input pixel format is converted to Mono16. This is useful when the input pixel format is Mono12, since this saves network bandwidth. Note that the FlyCap2 library does not support converting Raw12 to Mono16. The difference between Raw16 and Mono16 is that Mono16 has the sharpness and gamma corrections applied, while Raw16 does not.
- RGB8: The input format is converted to RGB8. This is useful when the input format is Raw8, for a color camera. In this case Bayer color is sent on the network, reducing the bandwidth requirement by a factor of 3.
- RGB16: The input format is converted to RGB16. This is useful when the input format is Raw16, for a color camera. In this case Bayer color is sent on the network, reducing the bandwidth requirement by a factor of 3.
PG_CONVERT_PIXEL_FORMAT
PGFrameRate
asynInt32
r/w
The frame rate choice when the VideoMode is not Format7. This is discussed in the Frame rates section above. The actual enum choices for this record will only include the frame rates supported by the camera in use for the VideoMode currently selected.
PG_FRAME_RATE
BinningMode
asynInt32
r/w
The binning mode for GigE cameras. The allowed values are camera-specific.
PG_BINNING_MODE
Property parameters These parameters apply to each of the 18 Point Grey properties discussed in the `Properties <#Properties>`__ section above. The $(PROPERTY) macro in this table is the EPICS record base name listed in that section. These records are defined in pointGreyProperty.template.
PGPropertyAvail
asynInt32
r/o
A flag indicating if the property is available.
PG_PROP_AVAIL
$(P)$(R)$(PROPERTY)Avail
bi
PGPropertyOnOffAvail
asynInt32
r/o
A flag indicating if the property supports turning on and off.
PG_PROP_ON_OFF_AVAIL
$(P)$(R)$(PROPERTY)OnOffAvail
bi
PGPropertyOnOff
asynInt32
r/w
Controls whether the property is on or off.
PG_PROP_ON_OFF
PGPropertyOnePushAvail
asynInt32
r/o
A flag indicating if the property supports setting once (called One Push). This is typically used for setting things like the gain or shutter time automatically once.
PG_PROP_ONE_PUSH_AVAIL
$(P)$(R)$(PROPERTY)OnePushAvail
bi
PGPropertyOnePush
asynInt32
r/w
Processing this record causes a one-push setting of the property.
PG_PROP_ONE_PUSH
$(P)$(R)$(PROPERTY)OnePush
bo
PGPropertyAbsAvail
asynInt32
r/o
A flag indicating if the property supports absolute (floating point) control.
PG_PROP_ABS_AVAIL
$(P)$(R)$(PROPERTY)AbsAvail
bi
PGPropertyAutoAvail
asynInt32
r/o
A flag indicating if the property supports automatic control.
PG_PROP_AUTO_AVAIL
$(P)$(R)$(PROPERTY)AutoAvail
bi
PGPropertyManAvail
asynInt32
r/o
A flag indicating if the property supports manual control.
PG_PROP_MAN_AVAIL
$(P)$(R)$(PROPERTY)ManAvail
bi
PGPropertyAutoMode
asynInt32
r/w
Controls whether the property is manually controlled or automatically controlled.
PG_PROP_AUTO_MODE
PGPropertyAbsAvail
asynInt32
r/o
A flag indicating if the property supports absolute (floating point) control.
PG_PROP_ABS_AVAIL
$(P)$(R)$(PROPERTY)AbsAvail
bi
PGPropertyAbsMode
asynInt32
r/w
Controls whether the property is controlled in integer device units or floating point absolute units.
PG_PROP_ABS_MODE
PGPropertyValue
asynInt32
r/w
The value of the property in integer device units. This controls the ValueA field of the property, which is the only integer field used for all properties except WHITE_BALANCE.
PG_PROP_VAL
PGPropertyValueB
asynInt32
r/w
The value of the property in integer device units. This controls the ValueB field of the property, which is only used to control the Blue value of WHITE_BALANCE.
PG_PROP_VAL_B
PGPropertyValueMin
asynInt32
r/o
The minimum value of the property in device units. This is used to control the LOPR and DRVL fields of the $(P)$(R)$(PROPERTY)Val record.
PG_PROP_VAL_MIN
$(P)$(R)$(PROPERTY)ValMin
ai
PGPropertyValueMax
asynInt32
r/o
The maximum value of the property in device units. This is used to control the HOPR and DRVH fields of the $(P)$(R)$(PROPERTY)Val record.
PG_PROP_VAL_MAX
$(P)$(R)$(PROPERTY)ValMax
ai
PGPropertyValueAbs
asynFloat64
r/w
The value of the property in floating point absolute units.
PG_PROP_VAL_ABS
PGPropertyValueAbsMin
asynFloat64
r/o
The minimum value of the property in absolute units. This is used to control the LOPR and DRVL fields of the $(P)$(R)$(PROPERTY)ValAbs record.
PG_PROP_VAL_ABS_MIN
$(P)$(R)$(PROPERTY)ValAbsMin
ai
PGPropertyValueAbsMax
asynFloat64
r/o
The maximum value of the property in absolute units. This is used to control the HOPR and DRVH fields of the $(P)$(R)$(PROPERTY)ValAbs record.
PG_PROP_VAL_ABS_MAX
$(P)$(R)$(PROPERTY)ValAbsMax
ai
GigE Property parameters These parameters apply to each of the 4 Point Grey GigE properties discussed in the `GigE Properties <#GigEProperties>`__ section above. The $(PROPERTY) macro in this table is the EPICS record base name listed in that section. These records are defined in pointGreyProperty.template.
PGPropertyValue
asynInt32
r/w
The value of the property in integer device units. This controls the ValueA field of the property, which is the only integer field used for all properties except WHITE_BALANCE.
PG_PROP_VAL
PGPropertyValueMin
asynInt32
r/o
The minimum value of the property in device units. This is used to control the LOPR and DRVL fields of the $(P)$(R)$(PROPERTY)Val record.
PG_PROP_VAL_MIN
$(P)$(R)$(PROPERTY)ValMin
ai
PGPropertyValueMax
asynInt32
r/o
The maximum value of the property in device units. This is used to control the HOPR and DRVH fields of the $(P)$(R)$(PROPERTY)Val record.
PG_PROP_VAL_MAX
$(P)$(R)$(PROPERTY)ValMax
ai
Trigger parameters
PGTriggerSource
asynInt32
r/w
The trigger source signal. Choices are “GPIO_0”, GPIO_1”,”GPIO_2”, and “GPIO_3”, which selects one of 4 GPIO pins on the camera. However, not all choices may be available on a specific camera, and the enum choices will only be the trigger sources actually supported on the camera in use.
PG_TRIGGER_SOURCE
PGTriggerPolarity
asynInt32
r/w
The trigger polarity. Choices are “Low”, and “High”.
PG_TRIGGER_POLARITY
PGSoftwareTrigger
asynInt32
r/w
Processing this record causes the driver to issue a software trigger.
PG_SOFTWARE_TRIGGER
$(P)$(R)SoftwareTrigger
bo
PGSkipFrames
asynInt32
r/w
The number of frames to skip when TriggerMode=”Skip frames”.
PG_SKIP_FRAMES
Strobe parameters
PGStrobeSource
asynInt32
r/w
The strobe output signal. Choices are “GPIO_0”, GPIO_1”,”GPIO_2”, and “GPIO_3”, which selects one of 4 GPIO pins on the camera. However, not all choices may be available on a specific camera, and the enum choices will only be the strobe sources actually supported on the camera in use.
PG_STROBE_SOURCE
PGStrobeEnable
asynInt32
r/w
Enables the strobe output. Choices are “Disable”, and “Enable”.
PG_STROBE_ENABLE
PGStrobePolarity
asynInt32
r/w
The strobe polarity. Choices are “Low”, and “High”.
PG_STROBE_POLARITY
PGStrobeDelay
asynFloat64
r/w
The delay of the strobe signal relative to the start of acquisition.
PG_STROBE_DELAY
PGStrobeDuration
asynFloat64
r/w
The duration of the strobe signal. If zero then the strobe output is asserted during the image aquisition time.
PG_STROBE_DURATION
Bandwidth control parameters
PGMaxPacketSize
asynInt32
r/o
The maximum packet size. This depends on the current acquisition settings for Firewire and USB cameras. For GigE cameras this is determined by calling DiscoverGigEPacketSize at startup, which should return the maximum Ethernet packet size supported between the camera and the IOC. However, this sometimes returns 9000 (jumbo packets) when jumbo packets are not in fact supported. In this case the user should manually set PacketSize to 1440 or image acquisition will fail.
PG_MAX_PACKET_SIZE
$(P)$(R)MaxPacketSize
longin
PGPacketSize
asynInt32
r/w
The packet size to use. This is used to control the maximum bandwidth, and hence maximum frame rate, on Firewire and USB cameras. For GigE cameras it should be set to the largest packet size supported on the Ethernet connection between the camera and IOC. It should be set to 1440 for connections that do not support jumbo packets, and as large as 9000 for connections that do support jumbo packets. If PacketSize is set to 0 then the driver will use the current value of MaxPacketSize.
PG_PACKET_SIZE
PGPacketSizeActual
asynInt32
r/o
The actual packet size being used.
PG_PACKET_SIZE_ACTUAL
$(P)$(R)PacketSizeActual
longin
PGPacketDelay
asynInt32
r/w
The packet delay to use in microseconds. This is used to control the maximum bandwidth, and hence maximum frame rate, on GigE cameras. It is not used for Firewire or USB cameras. The default is 400 microseconds. If the number of CorruptFrames is large then this can be increased, for example to 1000. This will reduce the maximum frame rate but can significantly reduce the number of CorruptFrames.
PG_PACKET_DELAY
PGPacketDelayActual
asynInt32
r/o
The actual packet delay being used.
PG_PACKET_DELAY_ACTUAL
$(P)$(R)PacketDelayActual
longin
PGBandwidth
asynFloat64
r/o
The calculated bandidth in MB/s. This is computed from the image size and the frame rate.
PG_BANDWIDTH
$(P)$(R)Bandwidth
ai
Timestamp parameters
PGTimeStampMode
asynInt32
r/w
The timestamp mode. Controls the value of the NDArray,.timeStamp value. Choices are:
- Camera: The time from the camera is used.
- EPICS: The EPICS time is used
- Hybrid: The EPICS time when the camera started is combined with the time stamp from the camera.
PG_TIME_STAMP_MODE
Camera statistics
PGCorruptFrames
asynInt32
r/o
The number of corrupt frames. The Point Grey SDK resets this to 0 each time acquisition is started.
PG_CORRUPT_FRAMES
$(P)$(R)CorruptFrames_RBV
longin
PGDroppedFrames
asynInt32
r/o
The number of dropped frames. The Point Grey SDK resets this to 0 each time acquisition is started.
PG_DROPPED_FRAMES
$(P)$(R)DroppedFrames_RBV
longin
PGDriverDropped
asynInt32
r/o
The number of frames dropped by the driver. The Point Grey SDK resets this to 0 each time acquisition is started.
PG_DRIVER_DROPPED
$(P)$(R)DriverDropped_RBV
longin
PGTransmitFailed
asynInt32
r/o
The number of time transmission failed. The Point Grey SDK resets this to 0 each time acquisition is started.
PG_TRANSMIT_FAILED
$(P)$(R)TransmitFailed_RBV
longin
Configuration¶
The Point Grey driver is created with the pointGreyConfig command, either from C/C++ or from the EPICS IOC shell.
pointGreyConfig(const char *portName, const char* cameraId, int traceMask, int memoryChannel,
int maxBuffers, size_t maxMemory,
int priority, int stackSize)
The cameraId parameter can either be an index of the camera in the list of available cameras (e.g. 0 if there is only a single Point Grey camera available) or the serial number of the camera to use. For additional details on the meaning of the parameters to this function refer to the detailed documentation on the pointGreyConfigConfig function in the pointGrey.cpp documentation and in the documentation for the constructor for the pointGrey class.
The traceMask can be set to a value > 1 to enable asynTrace debugging during initialization, before the value can be set from the IOC shell or via the asynRecord. Set this to 0x21 to enable ASYN_TRACE_WARNING, which will trace all calls to the Point Grey FlyCap2 library.
The memoryChannel can be set to a value > 0 to load the initial camera parameters from non-volatile memory in the camera. Setting memoryChannel to N loads from memoryChannel N-1, i.e. 1 loads memory channel 0. There is currently a problem with Linux and for BlackFly GigE cameras. If the IOC is run a second time after it has been used to acquire any images the driver loses communication with the camera. The problem appears to be that there is a corrupt setting in the camera, which causes it to malfunction the next time the program is run. Setting memoryChannel 1 will work around this problem by replacing the settings in the camera with a default set. Since the EPICS IOC sets nearly all the camera settings to save/restore values at startup anyway, this is not a serious limitation.
There an example IOC boot directory and startup script (iocBoot/iocPointGrey/st.cmd) provided with areaDetector.
MEDM screens¶
The following show the MEDM screens that are used to control the Point Grey cameras.
pointGrey.adl
is the main screen used to control Point Grey cameras.
pointGrey.adl
pointGreyProperties.adl
is the screen used to control the properties
of Point Grey cameras. Note that some of these properties, such as
Shutter, FrameRate, and Gain can also be controlled by standard
areaDetector records, like AcquireTime, AcquirePeriod, and Gain. The
widgets on the medm screen are hidden if the corresponding feature is
not available.
pointGreyProperties.adl for a BlackFly GigE color camera in RGB mode
|pointGreyProperties\_BlackFly.png| .. rubric:: pointGreyProperties.adl for a Grasshopper3 monochrome camera
name: pointgreyproperties.adl-for-a-grasshopper3-monochrome-camera
pointGreyFrameRate.adl
is the screen used to control the frame rate
in standard video modes. This is a separate screen because the valid
enum strings for the Framerate record can change when the standard video
mode is changed. When that is changed it is necessary to close this
screen and re-open it in order for the new menus to be displayed. This
is a limitation of the EPICS Channel Access which does not send monitor
events for changes in enum fields. Note that the readback of the
FrameRate on the main pointGrey.adl screen can also be incorrect, so it
may be necessary to close and re-open that main screen as well.
pointGreyFrameRate.adl
pointGreyPixelFormat.adl
is the screen used to control the pixel
format in Format7 mode. This is a separate screen because the valid enum
strings for the PixelFormat can change when the Format7 mode is changed.
When that is changed it is necessary to close this screen and re-open it
in order for the new menus to be displayed. This is a limitation of the
EPICS Channel Access which does not send monitor events for changes in
enum fields. Note that the readback of the PixelFormat on the main
pointGrey.adl screen can also be incorrect, so it may be necessary to
close and re-open that main screen as well.
pointGreyPixelFormat.adl


WELCOME
TO
E-library
OF
B.C.A.
CONTINUE
Semester 1
Semester 2
Semester 3
Semester 4
Semester 5
Semester 6
SUBJECT
home
Back
Mathematics I
Professional Communication
Computer Fundamentals & IT
Problem Solving & Programming Logic using C
Operating System
SUBJECT
home
Back
Mathematics II
Unix & Shell Programming
Data Structure Using C
Computer Organization
Environmental Science
SUBJECT
home
Back
Principles Of Management
Database Management System
Data Communication & Computer Networks
Discrete Mathematics
Software Engineering
SUBJECT
home
Back
E-commerce & application
Computer Graphics
Object Oriented Programming using C++
Human Values & Business Ethics
Financial Accounting
SUBJECT
home
Back
Computer Based Numerical Techniques
Java Programming
Internet & Web Technologies
Management Information System
Emerging Trends In Computing
SUBJECT
home
Back
Cryptography & Network Security/J2ME
GUI using .Net Framework
Mathematics I
home
Back
Unit I
Unit II
Unit III
Unit IV
Unit V
Professional Communication
home
Back
Unit I
Unit II
Unit III
Unit IV
Unit V
Computer Fundamentals & IT
home
Back
Unit I
Unit II
Unit III
Unit IV
Unit V
Problem Solving & Programming Logic using C
home
Back
Unit I
Unit II
Unit III
Unit IV
Unit V
Operating System
home
Back
Unit I
Unit II
Unit III
Unit IV
Unit V
Mathematics II
home
Back
Unit I
Unit II
Unit III
Unit IV
Unit V
Unix & Shell Programming
home
Back
Unit I
Unit II
Unit III
Unit IV
Unit V
Data Structure Using C
home
Back
Unit I
Unit II
Unit III
Unit IV
Unit V
Computer Organization
home
Back
Unit I
Unit II
Unit III
Unit IV
Unit V
Environmental Science
home
Back
Unit I
Unit II
Unit III
Unit IV
Unit V
Principles of Management
home
Back
Unit I
Unit II
Unit III
Unit IV
Unit V
Database Management System
home
Back
Unit I
Unit II
Unit III
Unit IV
Unit V
Data Communication & Computer Networks
home
Back
Unit I
Unit II
Unit III
Unit IV
Unit V
Discrete Mathematics
home
Back
Unit I
Unit II
Unit III
Unit IV
Unit V
Software Engineering
home
Back
Unit I
Unit II
Unit III
Unit IV
Unit V
E-commerce & applications
home
Back
Unit I
Unit II
Unit III
Unit IV
Unit V
Computer Graphics
home
Back
Unit I
Unit II
Unit III
Unit IV
Unit V
Object Oriented Programming using C++
home
Back
Unit I
Unit II
Unit III
Unit IV
Unit V
Human Values & Business Ethics
home
Back
Unit I
Unit II
Unit III
Unit IV
Unit V
Financial Accounting & Applications
home
Back
Unit I
Unit II
Unit III
Unit IV
Unit V
Computer Based Numerical Techniques
home
Back
Unit I
Unit II
Unit III
Unit IV
Unit V
Java Programming
home
Back
Unit I
Unit II
Unit III
Unit IV
Unit V
Internet & Web Technologies
home
Back
Unit I
Unit II
Unit III
Unit IV
Unit V
Management Information Systems
home
Back
Unit I
Unit II
Unit III
Unit IV
Unit V
Emerging Trends in Computing
home
Back
Unit I
Unit II
Unit III
Unit IV
Unit V
Cryptography & Network Security/J2ME
home
Back
Unit I
Unit II
Unit III
Unit IV
Unit V
GUI using .Net Framework
home
Back
Unit I
Unit II
Unit III
Unit IV
Unit V


| new_date {vctrs} | R Documentation |
A date
(Date) is a double vector. Its value represent the number
of days since the Unix "epoch", 1970-01-01. It has no attributes.
A datetime
(POSIXct is a double vector. Its value represents the
number of seconds since the Unix "Epoch", 1970-01-01. It has a single
attribute: the timezone (tzone
))
A duration
(difftime)
new_date(x = double()) new_datetime(x = double(), tzone = "") new_duration(x = double(), units = c("secs", "mins", "hours", "days", "weeks")) ## S3 method for class 'Date' vec_ptype2(x, y, ...) ## S3 method for class 'POSIXct' vec_ptype2(x, y, ...) ## S3 method for class 'POSIXlt' vec_ptype2(x, y, ...) ## S3 method for class 'difftime' vec_ptype2(x, y, ...) ## S3 method for class 'Date' vec_cast(x, to, ...) ## S3 method for class 'POSIXct' vec_cast(x, to, ...) ## S3 method for class 'POSIXlt' vec_cast(x, to, ...) ## S3 method for class 'difftime' vec_cast(x, to, ...) ## S3 method for class 'Date' vec_arith(op, x, y, ...) ## S3 method for class 'POSIXct' vec_arith(op, x, y, ...) ## S3 method for class 'POSIXlt' vec_arith(op, x, y, ...) ## S3 method for class 'difftime' vec_arith(op, x, y, ...)
x |
A double vector representing the number of days since UNIX
epoch for |
tzone |
Time zone. A character vector of length 1. Either |
units |
Units of duration. |
These function help the base Date
, POSIXct
, and difftime
classes fit
into the vctrs type system by providing constructors, coercion functions,
and casting functions.
new_date(0) new_datetime(0, tzone = "UTC") new_duration(1, "hours")