This guide discusses how to set up Box2D physics in your Corona app. Physics are commonly used for apps that involve a simulation of objects that move, collide, and interact under various physical forces like gravity.
Corona makes it very easy to add physics to your apps, even if you've never worked with a physics engine before. While the underlying engine is built around the popular Box2D, we've taken a different design approach which eliminates a lot of the coding that is traditionally required.
To work with the Corona physics engine, just begin with familiar Corona display objects. Corona treats physical body properties as an extension of its graphics objects: any standard display object including images, vector objects, or animated sprites can be "made physical" and they will automatically interact with other objects in the simulation.
Note that Corona automatically translates between its familiar onscreen units and the internal metric units of the physical simulation. All position values are exposed in pixels which are converted internally to meters at a default ratio of 30 pixels-per-meter. For further consistency, all angular values are exposed in degrees rather than radians, and position (0,0)
remains at the top left corner of the content area.
To begin using physics, you must require the library. The following line makes the physics engine available under the physics
namespace:
local physics = require( "physics" )
The following functions start, pause, and stop the physics simulation:
physics.start()
— either instantiates or resumes the simulation (if paused). You must start the physics simulation before calling any other physics functions in this guide.
physics.pause()
— pauses the physics simulation.
physics.stop()
— this is treated as a request to "destroy" the physics world. If you merely want to pause the physics engine, use physics.pause()
.
physics.start() --do this before any other physics call(s)
physics.pause()
physics.stop()
By default, physical bodies not involved in a collision will "sleep" after a few seconds. This reduces performance overhead, but in some cases you may not want this behavior. This is particularly true in apps that use the accelerometer to effect changes in physics gravity — in this case, sleeping bodies will not respond to changes in the direction of gravity.
You can override this behavior on any given body with the body.isSleepingAllowed = false
command (reference), or override it globally for all bodies in the world by using an optional boolean parameter in physics.start()
:
physics.start( true ) --prevent all bodies from sleeping
physics.start( false ) --default behavior; bodies may sleep after a few seconds
The physics engine features several global simulation options. These can be used to fine-tune your physics simulation beyond the default behavior.
physics.setGravity() sets the x and y components of the global gravity vector, in units of m/s². The default is ( 0, 9.8 )
to simulate standard Earth gravity, pointing downward on the y axis.
physics.setGravity( 0, 6 )
physics.setScale() sets the internal pixels-per-meter ratio that is used in converting between on-screen Corona coordinates and simulated physics coordinates. This should be done only once, before any physical objects are instantiated.
Changing this value has no visual consequences — it simply affects the accuracy of the physical model. The Box2D engine is tuned for simulating medium-sized objects between 0.1m and 10m in size, so it works best when the objects in your game are mapped to physical properties that fall roughly within this range.
The default scaling value is 30
, which means that the optimal 0.1m to 10m range corresponds to visible objects between 3 and 300 pixels in size. For larger objects, you may wish to increase this value to 60
or more.
physics.setScale( 60 )
You may also want to increase this value if the objects you are simulating seem too sluggish or react too slowly. In this case, they are likely too big and heavy for your purposes — try raising the scale value and/or reduce their densities.
physics.setDrawMode() sets one of three possible "rendering modes" for the physics engine. While this feature will run on devices, it's most useful in the Corona Simulator when debugging unexpected physics engine behavior.
physics.setDrawMode( "hybrid" ) --overlays collision outlines on normal display objects
physics.setDrawMode( "normal" ) --the default Corona renderer, with no collision outlines
physics.setDrawMode( "debug" ) --shows collision engine outlines only
Physics data is displayed using colored vector graphics which reflect different object types and attributes. See the Physics Bodies guide for details.
When working with Corona display groups and Box2D, it's important to remember that Box2D expects all physics objects to share a global coordinate system. Both grouped and ungrouped display objects will work well since they will share the internal coordinates of that group. However, unexpected results will occur if physical objects are added to different display groups and those groups are moved, scaled, or rotated independently of each other. As a general rule, do not alter the position, scale, or rotation of display groups that contain physics objects.
physics.setPositionIterations() sets the accuracy of the engine's position calculations.
physics.setPositionIterations( 16 )
The default value is 8
, which means that the engine will iterate through eight position approximations per frame for each object. Increasing this number will cause fewer momentary inaccuracies like overlapping objects, but it will increase computational overhead. The default value should work for most general cases.
physics.setVelocityIterations() sets the accuracy of the engine's velocity calculations.
physics.setVelocityIterations( 6 )
The default value is 3
, which means that the engine will iterate through three velocity approximations per frame for each object. Increasing this number will cause fewer momentary inaccuracies like overlapping objects, but it will increase computational overhead. The default value should work for most general cases.
physics.setContinuous() controls whether continuous physics is enabled or not. By default, Box2D performs continuous collision detection, which prevents objects from "tunneling." If it were turned off, an object that moves quickly enough could potentially pass through a thin wall.
In certain complex situations where bodies are connected by pivot joints (ragdolls, for example), instability can occur. One way to solve this is to turn up the number of velocity iterations using physics.setVelocityIterations(). However, this can be computationally expensive and reduce frame rates. Another solution is to disable continuous physics:
physics.setContinuous( false )
Turning it off should prevent the instability without increasing iterations. However, you'll need to make your static bodies extra thick to prevent tunneling effects.
physics.setAverageCollisionPositions() enables the averaging of all contact points in a collision between physics bodies. Because it's common for Box2D to report multiple collision points during a single frame iteration, this setting is useful to report those points as one averaged point.
physics.setAverageCollisionPositions( true )
physics.setReportCollisionsInContentCoordinates() sets the content origin as the reference point in the collision, preCollision, and postCollision physics events.
physics.setReportCollisionsInContentCoordinates( true )
physics.setDebugErrorsEnabled() allows extra physics errors to be caught by Box2D. Default is true
(enabled).
physics.setTimeStep() specifies either a frame-based (approximated) physics simulation or a time-based simulation.
physics.setTimeStep( 0 ) --time-based physics simulation
physics.setMKS() sets the MKS (meters, kilograms, and seconds) value of the physics simulation for specific keys. This is strictly for advanced purposes — the average developer and project will not require this function.


--- layout: page title: About header-img: "img/about-bg.png" ---
Thank you for visiting my blog and following me on my journey to becoming a web developer. "The happiest moment I felt; is that moment when I realized my ability to create." -Dr. Hazem Ali


Avi helped me get my new Macbook Air rolling this afternoon…
Ruby 1.8.7 is the standard version that’s loaded on the OS X Lion
Some lessons– Xcode did not come loaded with the GNU Compiler Collection out of the box (AKA out of app store). (-bash: gcc: command not found) GCC Installer
Anyways this had to be loaded to run anything like Homebrew.
- All OSs except for window are a NIX: A Unix-like (sometimes referred to as UNX or nix) operating system is one that behaves in a manner similar to a Unix system, while not necessarily conforming to or being certified to any version of the Single UNIX Specification. (http://en.wikipedia.org/wiki/Unix-like)
Once it was installed we got the result: i686-apple-darwin11-llvm-gcc-4.2: no input files from the gcc command. (read more about gcc here.
Homebrew was installed from here.
-Homebrew replaced the old style of loading software which required configuring the config file since all OSs are customized with different versions. This is frustrating as hell. Jewelry box, RVM, and homebrew are powerful enough to take the grunt work out of the environment set-up, but can’t the community find a way to wrap this in an app in the app store? Is this feasible?
We also modfiied the bash profile or dot files from Avi’s github repository.
- He mentioned that in the future I should choose a user name with all lower case letters rather than the capitalized name that I chose.
- I also needed to create a symbolic link for my sublime text editor so that I can call it from the command line (this is something I never figured out on my Fedora 15 system)
So for those keeping track at home:
- GCC
- Homebrew
- Jewelry box
- RVM
- Ruby Update
- Rails
No MySQL or anything like that… until I need it.


Burger and Fries
An American Classic!

Your choice - white or wheat bun
Relish, mustard, and ketchup
Served with our house-made chips
$7.95
Italian Sausage and Peppers
An All-Time Favorite!!
Your choice - mile or spicy
Cole Slaw
Served with garlic mashers
$10.95
Tenderloin Sandwich and Chips
Really Hits the Spot!
Plain or Sesame Seed Bun
Pickle, onion, tomato, and lettuce
Served with our house-made chips
$8.95
House Salad
On the Lighter Side
Your choice - with or without cheese
Iceberg lettuce, tomatoes, peppers
Thousand Island or Ranch Dressing
Served with a dinner roll
$6.95
Brisket Sandwich and Fries
A tastes of Texas!
Smoked Brisket on thick-cut Texas
Toast
Cole Slaw
Served with our famous thick-cut
frenc fries
$7.95


QML Dynamic View Ordering Tutorial 3 - Moving Dragged Items
The next step in our application to move items within the list as they're dragged so that we can re-order the list. To achieve this we introduce three new types to our application; DelegateModel, Drag and DropArea.
Rectangle { id: root width: 300; height: 400 Component { id: dragDelegate MouseArea { id: dragArea property bool held: false anchors { left: parent.left; right: parent.right } height: content.height drag.target: held ? content : undefined drag.axis: Drag.YAxis onPressAndHold: held = true onReleased: held = false Rectangle { id: content Drag.active: dragArea.held Drag.source: dragArea Drag.hotSpot.x: width / 2 Drag.hotSpot.y: height / 2 } DropArea { anchors { fill: parent; margins: 10 } onEntered: { visualModel.items.move( drag.source.DelegateModel.itemsIndex, dragArea.DelegateModel.itemsIndex) } } } } }
Walkthrough
In order to re-order the view we need to determine when one item has been dragged over another. With the Drag attached property we can generate events that are sent to the scene graph whenever the item it is attached to moves.
Drag.active: dragArea.held Drag.source: dragArea Drag.hotSpot.x: width / 2 Drag.hotSpot.y: height / 2
Drag events are only sent while the active property is true, so in this example the first event would be sent when the delegate was held with additional event sents when dragging. The hotSpot property specifies the relative position of the drag events within the dragged item, the center of the item in this instance.
Then we use a DropArea in each view item to determine when the hot spot of the dragged item intersects another item, when a drag enters one of these DropAreas we can move the dragged item to the index of the item it was dragged over.
DropArea { anchors { fill: parent; margins: 10 } onEntered: { visualModel.items.move( drag.source.DelegateModel.itemsIndex, dragArea.DelegateModel.itemsIndex) } }
To move the items within the view we use a DelegateModel. The DelegateModel type is used by the view types to instantiate delegate items from model data and when constructed explicitly can be used to filter and re-order the model items provided to ListView. The items property of DelegateModel provides access to the view's items and allows us to change the visible order without modifying the source model. To determine the current visible index of the items we use itemsIndex {itemsIndex} property on the DelegateModel attached property of the delegate item.
To utilize a DelegateModel with a ListView we bind it to the model property of the view and bind the model and delegate to the DelegateModel.
DelegateModel { id: visualModel model: PetsModel {} delegate: dragDelegate } ListView { id: view anchors { fill: parent; margins: 2 } model: visualModel spacing: 4 cacheBuffer: 50 }
Files:


Graphics are very effective for communicating numerical information quickly and efficiently, but many of the design choices we make are based on subjective measures, such as personal taste or conventions of the discipline rather than objective criteria. We briefly introduce perceptual principles such as pre-attentive features and gestalt heuristics, and then discuss the design and results of a factorial experiment using visual inference to examine the effect of plot aesthetics such as color and trend lines on participants' assessment of ambiguous data displays. The quantitative and qualitative experimental results strongly suggest that plot aesthetics have a significant impact on the perception of important features in data displays.


| practical1_model | index c:\users\liz\documents\python\geog5995\practicals\abm\restart\practicals---final\submission\practical1_model.py |
Created on Mon Sep 30 08:45:49 2019
@author: liz
This file is covered by the LICENSING file in the root of this project.
Makes 2 agents, moves them and defines distance_between to
calculate distance betwen 2 agents
| Modules | ||||||
|
| Data | ||
| distance_between = 28.442925306655784 i = 2 num_of_iterations = 3 x0 = 91 x1 = 86 y0 = 57 y1 = 29 |


The Huton Collection
Go Home
Add New Movies
Manage Existing Movies
(current)
View Messages
Manage Existing Films
Embrace, Create
#
Title
Description
Price
Actions
Editing Item Detail
×
Title
Description
Price
$
Poster


A project dedicated to showing my brothers the power of computer science and all that it helps create.
Based on the 2008 board game Khet


Find ATM Locations
[Num Notifications]
You have
[Num Notifications]
Notification[s]
[Msg Content]
0
You have 0 Unread Mail[s]
My Profile
Change Password
Logout
×
Welcome


# 1 Introduction
----
![image](../images/fig1_1_phases_of_a_compiler_and_interfaces_between_them.PNG)
----
## 1.1 Modules and Interfaces
----
![image](../images/table_1_2_description_of_compiler_phases.PNG)
----
## 1.2 Tools and Software
----
two of the most useful abstractions used in modern compilers are:
1. *context-free grammars*, for parsing, `Yacc` ( converts a grammar into a parsing program );
2. *regular expressions*, for lexical analysis, `Lex` ( converts a declarative specification into a lexical analysis program ) .
----
## 1.3 Data Structures for Tree languages
----
A simple programming language with statements and expressions, but no loops or if-statements, which is called a language of *straight-line programs*.
![image](../images/grammar_1_3_a_straight_line_programming_language.PNG)
The informal semantics of the language is as follows:
1. Each $Stm$ is a statement;
2. Each $Exp$ is an expression;
3. $s_1;s_2$ executes statement $s_1$, then statement $s_2$;
4. $i:=e$ evaluates the expression $e$, then stores the result in variable $i$;
5. $print(e_1, e_2, ... , e_n)$ displays the values of all the expressions, evaluated left to right, separated by spaces, terminated by a newline;
6. An *identifier expression*, such as $i$, yields the current contents of the variable $i$;
7. A *number* evaluates to the named integer;
8. An *operator expression $e_1$ op $e_2$* evaluates $e_1$, then $e_2$, then applies the given binary operator;
9. An *expression sequence (s, e)* evaluating $s$ for side effects before evaluating (and returning the result of) the expression $e$.
For example, executing this program
```
a := 5+3; b := (print (a, a-1), 10*a); print(b)
```
prints
```
8 7
80
```
The program be represented inside a compiler:
1. *source code*, likes above.
2. *tree data structure*, with one node for each statement (stm) and expression (Exp), likes Figure 1.4 shows.
![image](../images/figure_1_4_tree_representation_of_a_straight_line_program.PNG)
```c
typedef char* string; //字符串
typedef struct A_stm_* A_stm; //statement节点指针
typedef struct A_exp_* A_exp; //expression节点指针
typedef struct A_expList_* A_expList;//expression list节点指针
//操作符类型
typedef enum { A_plus, A_minus, A_times, A_div } A_binop;
//statement节点类型
struct A_stm_ {
//三种statement：复合型，赋值型，打印型
enum { A_compoundStm, A_assignStm, A_printStm } kind;
//不同类型的statement有不同的数据内容
union {
//复合型包含两个statement节点的指针
struct { A_strm stm1, stm2; } compound;
//赋值型包含变量名（字符串指针）和expression节点的指针
struct { string id; A_exp exp; } assign;
//打印型包含一个expression list节点的指针
struct { A_expList exps; } print;
} u;
};
//创建statement节点
A_stm A_CompoundStm( A_stm stm1, A_stm stm2 ); //复合statement节点
A_stm A_AssignStm( string id, A_exp exp ); //赋值节点
A_stm A_PrintStm( A_expList exps ); //打印节点
//expression节点类型
struct A_exp_ {
//四种expression：id（用字符串指针指向指定名字的变量）
// number（直接就是对应一个整数）
// op（对应一个二元算术表达式：exp1 op exp2，
// exp1和exp2都是指向一个表达式节点的指针，
// op是操作符类型）
// eseq（对应一个“，”表达式：(stm, exp),
// stm指向一个statement节点，
// exp指向一个expression节点）
enum { A_idExp, A_numExp, A_opExp, A_eseqExp } kind;
//不同的expression节点类型有不同的数据，见上说明。
union {
string id;
int num;
struct { A_exp left; A_binop oper; A_exp right; } op;
struct { A_stm stm; A_exp exp; } eseq;
} u;
};
//创建expression节点
A_exp A_IdExp( string id );
A_exp A_NumExp( int num );
A_exp A_OpExp( A_exp left, A_binop oper, A_exp right );
A_exp A_EseqExp( A_stm stm, A_exp exp );
//expression list节点
struct A_expList_ {
// 两种expression list的类型：
// pair型（对应一个pair表达式：(head, tail),
// head指向一个expression节点，
// tail指向一个expression list节点）
// last型（只对应一个节点指针：last
// last指向一个expression节点）
enum { A_pairExpList, A_lastExpList } kind ;
union {
struct { A_exp head; A_expList tail; } pair;
A_exp last;
} u;
};
//创建一个expression list节点
A_expList A_PairExpList( A_exp head, A_expList tail );
A_expList A_LastExpList( A_exp last);
```
PROGRAM 1.5 representation of straight-line programs.
---
Grammar | typedef
----------|---------------
$Stm$ | `A_stm`
$Exp$ | `A_exp`
$ExpList$ | `A_expList`
$id$ | `string`
$num$ | `int`
----
For each variant ( `CompoundStm`, `AssignStm`, etc. ) we make a *constructor function* to `malloc` and initialize the data structure. In Program 1.5 only the prototypes of these functions are given; the definition of the node creation would look likes this:
```C
A_stm A_CompoundStm ( A_stm stm1, A_stm stm2 ){
A_stm s = checked_malloc(sizeof(*s));
s->kind = A_compoundStm;
s->u.compound.stm1 = stm1;
s->u.compound.stm2 = stm2;
return s;
}
```
### Programming style.
1. Trees are described by a grammar.
2. A tree is described by one or more `typedef`s, corresponding to a symbol in the grammar.
3. Each `typedef` defines a pointer to a corresponding `struct`. The `struct` name is never used.
4. Each `struct` contains a `kind` field, which is an enum showing different variants, one for each grammar rule; and a `u` field, which is a union.
5. Every class will have a constructor function that initializes all the fields. The `malloc` function shall never be called directly, expect in these constructor functions.
6. Each module ( header file ) shall have a prefix unique to that module( example, `A_` in Program 1.5 )
7. `typedef` names ( after the prefix ) shall start with lowercase letters; constructor functions ( after the prefix ) with uppercase; enumeration atoms ( after the prefix ) with lowercase; and union variants ( which have no prefix ) with lowercase.
### Modularity principles for C programs.
* Each phase or module of the compiler belongs in its own ".c" file, which will have a corresponding ".h" file.
* Each module shall have a prefix unique to that module. All global names ( structure and union fields are not global names ) exported by the module shall start with the prefix. Then the human reader of a file will not have to look outside that file to determine where a name comes from.
* All functions shall have prototypes, and the C compiler shall be told to warn about uses of functions without prototypes.
* We will `#include "util.h" ` in each file:
```c
/* util.h */
#include
typedef char* string;
string String ( char* );
typedef char bool;
#define TRUE 1
#define FALSE 0
void *checked_malloc ( int );
```
the inclusion of `assert.h` encourages the liberal use of assertions by the C programmer.
* The `string` type means a heap-allocated string that will not be modified after its initial creation. The `String` function builds a heap-allocated `string` from a C-Style character pointer ( just like the standard C library function `strdup` ). Functions that take `string`s as arguments assume that the contents will never change.
* C's `malloc` function returns `NULL` if there is no memory left. We use `checked_malloc` , which guarantees never to return `NULL`:
```c
void *checked_malloc( int len ){
void* p = malloc( len );
assert( p );
return p;
}
```
* We will never call `free`. Of course, a production-quality compiler must free its unused data in order to avoid wasting memory.
## Straight-line Program Interpreter
This exercise serves as an introduction to *environments* ( symbol tables mapping variable-names to information about )


Split it with me allows you to easily divide shared expenses with your friends and you will never have to worry about splitting the bills again.
Spend more time with the people you love and less time griping over the bill. Save it for the times that really count.
Seamless integration with Venmo allows you to quickly add and divide expenditures among friends while getting your money back with the click of a single button.


Street Fighter V Champion Edition Announced; Gill Confirmed As New Character
by Francesco De MeoA new edition of Street Fighter V, Street Fighter V Champion Edition, has been announced for PC and PlayStation 4.
The new edition of the latest entry in the popular fighting game series by Capcom has been announced at the end of the Capcom Pro Tour North American Regional Finals yesterday. This new version of the game will include all the content released for the game so far, including additional DLC characters, stages, and costumes. Street Fighter V Champion Edition is available right now as an upgrade pack for owners of Street Fighter V and Street Fighter V Arcade Edition, and it will release in February at retail.
Half-Life Alyx To Be Unveiled Next Month At The Game Awards – Rumor
Capcom also revealed some of the changes coming to the game next year. Alongside a new balance update, all characters will receive a second V-Skill, some of them shown in the announcement trailer. Additionally, it's been confirmed that the Street Fighter III games final boss, Gill, will be released next month.
Gill, a master of both pyrokinesis and cryokinesis, is able to control fire and ice with perfect elemental balance (hence his outward appearance). Typically plotting behind the scenes, he is now ready to reveal himself to the world, as he sets out to fulfill the prophecy that the Secret Society has coveted since ancient times. Gill brings his “Retribution” to SFV Champion Edition in December 2019.
Street Fighter V Champion Edition launches at retails in February. The upgrade pack is available for purchase right now on PC and PlayStation 4.


Wally West was the Nephew of Iris West, then girlfriend of the previous Flash, Barry Allen. During and introduction to Barry Allen , Wally was struck with the same lightning bolt that granted Barry Allen his powers of super speed to become the Flash.
Shortly after the accident, he took up the moniker of Kid Flash and ran side by side with his mentor The Flash. Together they fought crime in Central City.
During his time as Kid Flash, Wally also fought along the side of the Teen Titans. They were a group of sidekicks that fought evil together. The other members of that group included:
During the Crisis on Infinite Earth event, Barry Allen sacrifieced his life in a battle with Anit-monitor. He then took up the mantle of The Flash in his place.


Number of Persons Injured
Number of Persons Killed
Number of Motorists Injured
Number of Motorists Killed
Number of Cyclists Injured
Number of Cyclists Killed
Number of Pedestrians Injured
Number of Pedestrians Killed


COMING SOON
For more details you can contact us below our links.
Navbar
Search
Previous
Next
WHATSAPP.
FACEBOOK.
TWITTER.


Getting Started
Lets get started using blacksmith. The main idea here is to get you to through the installation process of the script in any project you want to add it and give you the basic usage on how you can use your commands.
Installation
The first thing we need to do is to get Blacksmith. To do that you can go to the github repository and download it manually but if course we think the best way to include it would be using composer. So thats what we are going to do:
composer require eaperezc/blacksmith
Bootstrap
After composer finished downloading the library, you will have it on your vendor folder inside of the bin folder. Of course you could access it using that file but we think is easier of you have it on the root folder. If you copy and paste the blackmith file manually it would work of course but to bootstrap we created a helper command you can run:
./vendor/bin/blacksmith bootstrap
# The commands folder and the blacksmith script will be available to use
Help
Any command that is available it will automatically appear in the help section of blacksmith. To see the help you just type the following:
php blacksmith
# Or php blacksmith help also works
Usage
You’ll see that the way we can call any command using blacksmith is the one that we see in the help menu. Of course each command works differently and some of them wont have the need of arguments. See the example:
php blacksmith [signature] [arguments]
# Example:
php blacksmith make:cmd ExampleCommand
I will continue to add more documentation here as soon as we have more things to show. Specially on how to create custom commands and register them in blacksmith. Have a good one!


System Architect Definitions, Encyclopedia:"D:\DATA\SYSARCH\HCM\GEN_DATA\SUBJECT\V01\CURRENT\"
Focus For Further Activity (Class)
- Allow Shared:
F
- Override Shared:
F
- Default Shared:
F
- Allow Transactional:
F
- Override Transactional:
F
- Default Transactional:
F
- Allow Monitored:
F
- Override Monitored:
F
- Default Monitored:
F
- Allow Distributed:
F
- Override Distributed:
F
- Default Distributed:
F
- Normalize:
F
- Abstract:
F
- Derived:
F
- Description:
"Property Qualifier" being an "Agent's" view of a "Subject Property" which may have attention
directed towards it.
- Source:
post-CBS
- State Type:
F
- &Abstract:
F
- Value:
F
focus for qualification (Association)
- From Class:
"Subject Property"
- To Class:
"Subject Property Qualifier"
- Redefines:
"Phenomenon Or Qualifier"."Phenomenon Qualifier"."focus for qualification"
focus for qualification (Association)
- From Class:
"Activity For Subject"
- To Class:
"Activity Qualifier"
- Redefines:
"Phenomenon Or Qualifier"."Phenomenon Qualifier"."focus for qualification"
focus for qualification (Association)
- From Class:
"Phenomenon Or Qualifier"
- To Class:
"Phenomenon Qualifier"
focus for (Association)
- From Class:
"Established Focus"
- To Class:
"Intention Under Consideration"
focus for (Association)
- From Class:
"Focus For Further Activity"
- To Class:
"Focus State"
Focus State Change (Class)
- Description:
"Activity" changing the state of a "Focus For Further Activity".
- Source:
post-CBS
- State Type:
F
- &Abstract:
F
- Value:
F
Focus State Type (Class)
- Description:
"State Type" being one of the permissible states for "Focus For Further Activity".
- Source:
HcM QA
- State Type:
F
- &Abstract:
F
- Value:
F
Focus State (Class)
- Description:
"Focus For Further Activity" in a state which it is currently or has been previously.
- Comment:
Note that there are both subtypes (comprising all the possible states) and a "power type" of "Focus
State Type". The latter's contents are identical to the subtypes; it exists in order to control
topics such as access and permission to amend.
- Source:
HcM QA
- State Type:
F
- &Abstract:
F
- Value:
F
for performance start (Association)
- From Class:
Location
- To Class:
"Activity To Be Done"
for performance (Association)
- From Class:
Location
- To Class:
"Performer Accepted Activity"
for some (Association)
- From Class:
"Subject Characteristic Type"
- To Class:
"Authorised Agent"


patrick county va gis
Patrick County, VA public records locator
The following table lists all online resources for Patrick County, VA public . to: maps and other geographic information systems (gis), databases of recorded .
http://recordsprovider.com/county-records/Patrick-VA
Floyd County, VA
Notes: Search results appear in the search results area at the bottom. If no matches are found when searching, try using a more general search. ex. Instead of .
http://www.floydcova.org/webgis/
Patrick County, VA - BRB Publications, Inc.
Search through our extensive database of Patrick County public, vital, and . VA - Patrick County - Property Tax and Ownership, GIS/Mapping - Must register.
http://www.brbpub.com/virginia/patrick/
Things You'll Need
- Certified copies of public records evidence in your case
Instructions
-
-
1
United States, Virginia, Patrick - Free GIS Data - GIS Data Depot
GISDataDepot.com -- THE leading provider of On-Line GIS Data. Country Index > > United States >> Virginia >>. Patrick County, Virginia, United States .
http://data.geocomm.com/catalog/US/61079/1782/index.htmlTax Mapping | Patrick County Government
County GIS. Patrick County Virginia Administration Offices 106 Rucker Street | P.O. Box 466 | Stuart, Virginia 24171. Ph:<PHONE_NUMBER> | Fax:<PHONE_NUMBER> .
http://co.patrick.va.us/tax-mapping -
2
Patrick County, Virginia Public Records Directory
Patrick County, Virginia Public Records Directory - Quickly find public record . Map of Virginia showing Patrick County - Click on map for a greater detail.
http://publicrecords.onlinesearches.com/VA_Patrick.htmnetGIS - Washington County, VA
. VA Creeper Trail, Virginia Highlands Airport, Virginia Highlands Festival . Mt Rogers FD/RS, Mud Hollow Conv Sta, Patrick Henry High, RHEA Valley Elem .
http://netgis.washcova.com/ -
-
3
Patrick County, Virginia detailed profile - houses, real estate, cost of ...
Mar. 2012 cost of living index in Patrick County: 82.7 (low, U.S. average is 100). We are giving away a $200 prize - enter simply by sending us your own pictures .
http://www.city-data.com/county/Patrick_County-VA.htmlHome | Patrick County Government
Patrick County, Virginia is the perfect place to live, visit or relocate your business. Learn about county characteristics, governmental services, and places to stay.
http://www.co.patrick.va.us/ -
4
GISPilot.com - Virginia State and City GIS links
Virginia State and County GIS links. . Virginia Dept of Forestry GIS Data · VDGIF (Va Dept Game/Inland Fisheries) . Orange County GIS · Patrick County GIS .
http://www.gispilot.com/States/Virginia.htmlPatrick County iGIS - InteractiveGIS, Inc.
This is Patrick County, Virginia's iGIS web site. If you have any<EMAIL_ADDRESS>va.us) for assistance. . PATRICK COUNTY AND INTERACTIVEGIS, INC.
http://www.patrick.interactivegis.com/
-
1
References
Resources
- Photo Credit Justice image by MVit from midas jobs in north carolina


| 1 | /* =========================================================== | |
| 2 | * JFreeChart : a free chart library for the Java(tm) platform | |
| 3 | * =========================================================== | |
| 4 | * | |
| 5 | * (C) Copyright 2000-2009, by Object Refinery Limited and Contributors. | |
| 6 | * | |
| 7 | * Project Info: http://www.jfree.org/jfreechart/index.html | |
| 8 | * | |
| 9 | * This library is free software; you can redistribute it and/or modify it | |
| 10 | * under the terms of the GNU Lesser General Public License as published by | |
| 11 | * the Free Software Foundation; either version 2.1 of the License, or | |
| 12 | * (at your option) any later version. | |
| 13 | * | |
| 14 | * This library is distributed in the hope that it will be useful, but | |
| 15 | * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY | |
| 16 | * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public | |
| 17 | * License for more details. | |
| 18 | * | |
| 19 | * You should have received a copy of the GNU Lesser General Public | |
| 20 | * License along with this library; if not, write to the Free Software | |
| 21 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, | |
| 22 | * USA. | |
| 23 | * | |
| 24 | * [Java is a trademark or registered trademark of Sun Microsystems, Inc. | |
| 25 | * in the United States and other countries.] | |
| 26 | * | |
| 27 | * -------------------- | |
| 28 | * FastScatterPlot.java | |
| 29 | * -------------------- | |
| 30 | * (C) Copyright 2002-2009, by Object Refinery Limited. | |
| 31 | * | |
| 32 | * Original Author: David Gilbert (for Object Refinery Limited); | |
| 33 | * Contributor(s): Arnaud Lelievre; | |
| 34 | * | |
| 35 | * Changes | |
| 36 | * ------- | |
| 37 | * 29-Oct-2002 : Added standard header (DG); | |
| 38 | * 07-Nov-2002 : Fixed errors reported by Checkstyle (DG); | |
| 39 | * 26-Mar-2003 : Implemented Serializable (DG); | |
| 40 | * 19-Aug-2003 : Implemented Cloneable (DG); | |
| 41 | * 08-Sep-2003 : Added internationalization via use of properties | |
| 42 | * resourceBundle (RFE 690236) (AL); | |
| 43 | * 16-Sep-2003 : Changed ChartRenderingInfo --> PlotRenderingInfo (DG); | |
| 44 | * 12-Nov-2003 : Implemented zooming (DG); | |
| 45 | * 21-Jan-2004 : Update for renamed method in ValueAxis (DG); | |
| 46 | * 26-Jan-2004 : Added domain and range grid lines (DG); | |
| 47 | * 25-Feb-2004 : Replaced CrosshairInfo with CrosshairState (DG); | |
| 48 | * 29-Sep-2004 : Removed hard-coded color (DG); | |
| 49 | * 04-Oct-2004 : Reworked equals() method and renamed ArrayUtils | |
| 50 | * --> ArrayUtilities (DG); | |
| 51 | * 12-Nov-2004 : Implemented the new Zoomable interface (DG); | |
| 52 | * 05-May-2005 : Updated draw() method parameters (DG); | |
| 53 | * 16-Jun-2005 : Added get/setData() methods (DG); | |
| 54 | * ------------- JFREECHART 1.0.x --------------------------------------------- | |
| 55 | * 10-Nov-2006 : Fixed bug 1593150, by not allowing null axes, and added | |
| 56 | * setDomainAxis() and setRangeAxis() methods (DG); | |
| 57 | * 20-Jun-2007 : Removed JCommon dependencies (DG); | |
| 58 | * 24-Sep-2007 : Implemented new zooming methods (DG); | |
| 59 | * 25-Mar-2008 : Make use of new fireChangeEvent() method (DG); | |
| 60 | * 18-Dec-2008 : Use ResourceBundleWrapper - see patch 1607918 by | |
| 61 | * Jess Thrysoee (DG); | |
| 62 | * 26-Mar-2009 : Implemented Pannable, and fixed bug in zooming (DG); | |
| 63 | * | |
| 64 | */ | |
| 65 | ||
| 66 | package org.jfree.chart.plot; | |
| 67 | ||
| 68 | import java.awt.AlphaComposite; | |
| 69 | import java.awt.BasicStroke; | |
| 70 | import java.awt.Color; | |
| 71 | import java.awt.Composite; | |
| 72 | import java.awt.Graphics2D; | |
| 73 | import java.awt.Paint; | |
| 74 | import java.awt.Shape; | |
| 75 | import java.awt.Stroke; | |
| 76 | import java.awt.geom.Line2D; | |
| 77 | import java.awt.geom.Point2D; | |
| 78 | import java.awt.geom.Rectangle2D; | |
| 79 | import java.io.IOException; | |
| 80 | import java.io.ObjectInputStream; | |
| 81 | import java.io.ObjectOutputStream; | |
| 82 | import java.io.Serializable; | |
| 83 | import java.util.Iterator; | |
| 84 | import java.util.List; | |
| 85 | import java.util.ResourceBundle; | |
| 86 | ||
| 87 | import org.jfree.chart.axis.AxisSpace; | |
| 88 | import org.jfree.chart.axis.AxisState; | |
| 89 | import org.jfree.chart.axis.NumberAxis; | |
| 90 | import org.jfree.chart.axis.ValueAxis; | |
| 91 | import org.jfree.chart.axis.ValueTick; | |
| 92 | import org.jfree.chart.event.PlotChangeEvent; | |
| 93 | import org.jfree.chart.util.ArrayUtilities; | |
| 94 | import org.jfree.chart.util.ObjectUtilities; | |
| 95 | import org.jfree.chart.util.PaintUtilities; | |
| 96 | import org.jfree.chart.util.RectangleEdge; | |
| 97 | import org.jfree.chart.util.RectangleInsets; | |
| 98 | import org.jfree.chart.util.ResourceBundleWrapper; | |
| 99 | import org.jfree.chart.util.SerialUtilities; | |
| 100 | import org.jfree.data.Range; | |
| 101 | ||
| 102 | /** | |
| 103 | * A fast scatter plot. | |
| 104 | */ | |
| 105 | public class FastScatterPlot extends Plot implements ValueAxisPlot, Pannable, | |
| 106 | Zoomable, Cloneable, Serializable { | |
| 107 | ||
| 108 | /** For serialization. */ | |
| 109 | private static final long serialVersionUID =<PHONE_NUMBER>358563521L; | |
| 110 | ||
| 111 | /** The default grid line stroke. */ | |
| 112 | public static final Stroke DEFAULT_GRIDLINE_STROKE = new BasicStroke(0.5f, | |
| 113 | BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL, 0.0f, new float[] | |
| 114 | {2.0f, 2.0f}, 0.0f); | |
| 115 | ||
| 116 | /** The default grid line paint. */ | |
| 117 | public static final Paint DEFAULT_GRIDLINE_PAINT = Color.lightGray; | |
| 118 | ||
| 119 | /** The data. */ | |
| 120 | private float[][] data; | |
| 121 | ||
| 122 | /** The x data range. */ | |
| 123 | private Range xDataRange; | |
| 124 | ||
| 125 | /** The y data range. */ | |
| 126 | private Range yDataRange; | |
| 127 | ||
| 128 | /** The domain axis (used for the x-values). */ | |
| 129 | private ValueAxis domainAxis; | |
| 130 | ||
| 131 | /** The range axis (used for the y-values). */ | |
| 132 | private ValueAxis rangeAxis; | |
| 133 | ||
| 134 | /** The paint used to plot data points. */ | |
| 135 | private transient Paint paint; | |
| 136 | ||
| 137 | /** A flag that controls whether the domain grid-lines are visible. */ | |
| 138 | private boolean domainGridlinesVisible; | |
| 139 | ||
| 140 | /** The stroke used to draw the domain grid-lines. */ | |
| 141 | private transient Stroke domainGridlineStroke; | |
| 142 | ||
| 143 | /** The paint used to draw the domain grid-lines. */ | |
| 144 | private transient Paint domainGridlinePaint; | |
| 145 | ||
| 146 | /** A flag that controls whether the range grid-lines are visible. */ | |
| 147 | private boolean rangeGridlinesVisible; | |
| 148 | ||
| 149 | /** The stroke used to draw the range grid-lines. */ | |
| 150 | private transient Stroke rangeGridlineStroke; | |
| 151 | ||
| 152 | /** The paint used to draw the range grid-lines. */ | |
| 153 | private transient Paint rangeGridlinePaint; | |
| 154 | ||
| 155 | /** | |
| 156 | * A flag that controls whether or not panning is enabled for the domain | |
| 157 | * axis. | |
| 158 | * | |
| 159 | * @since 1.0.13 | |
| 160 | */ | |
| 161 | private boolean domainPannable; | |
| 162 | ||
| 163 | /** | |
| 164 | * A flag that controls whether or not panning is enabled for the range | |
| 165 | * axis. | |
| 166 | * | |
| 167 | * @since 1.0.13 | |
| 168 | */ | |
| 169 | private boolean rangePannable; | |
| 170 | ||
| 171 | /** The resourceBundle for the localization. */ | |
| 172 | protected static ResourceBundle localizationResources | |
| 173 | = ResourceBundleWrapper.getBundle( | |
| 174 | "org.jfree.chart.plot.LocalizationBundle"); | |
| 175 | ||
| 176 | /** | |
| 177 | * Creates a new instance of FastScatterPlot with default | |
| 178 | * axes. | |
| 179 | */ | |
| 180 | public FastScatterPlot() { | |
| 181 | this(null, new NumberAxis("X"), new NumberAxis("Y")); | |
| 182 | } | |
| 183 | ||
| 184 | /** | |
| 185 | * Creates a new fast scatter plot. | |
| 186 | *
 | |
| 187 | * The data is an array of x, y values: data[0][i] = x, data[1][i] = y. | |
| 188 | * | |
| 189 | * @param data the data (null permitted). | |
| 190 | * @param domainAxis the domain (x) axis (null not permitted). | |
| 191 | * @param rangeAxis the range (y) axis (null not permitted). | |
| 192 | */ | |
| 193 | public FastScatterPlot(float[][] data, | |
| 194 | ValueAxis domainAxis, ValueAxis rangeAxis) { | |
| 195 | ||
| 196 | super(); | |
| 197 |
1
1. |
if (domainAxis == null) { |
| 198 | throw new IllegalArgumentException("Null 'domainAxis' argument."); | |
| 199 | } | |
| 200 |
1
1. |
if (rangeAxis == null) { |
| 201 | throw new IllegalArgumentException("Null 'rangeAxis' argument."); | |
| 202 | } | |
| 203 | ||
| 204 | this.data = data; | |
| 205 | this.xDataRange = calculateXDataRange(data); | |
| 206 | this.yDataRange = calculateYDataRange(data); | |
| 207 | this.domainAxis = domainAxis; | |
| 208 |
1
1. |
this.domainAxis.setPlot(this); |
| 209 |
1
1. |
this.domainAxis.addChangeListener(this); |
| 210 | this.rangeAxis = rangeAxis; | |
| 211 |
1
1. |
this.rangeAxis.setPlot(this); |
| 212 |
1
1. |
this.rangeAxis.addChangeListener(this); |
| 213 | ||
| 214 | this.paint = Color.red; | |
| 215 | ||
| 216 | this.domainGridlinesVisible = true; | |
| 217 | this.domainGridlinePaint = FastScatterPlot.DEFAULT_GRIDLINE_PAINT; | |
| 218 | this.domainGridlineStroke = FastScatterPlot.DEFAULT_GRIDLINE_STROKE; | |
| 219 | ||
| 220 | this.rangeGridlinesVisible = true; | |
| 221 | this.rangeGridlinePaint = FastScatterPlot.DEFAULT_GRIDLINE_PAINT; | |
| 222 | this.rangeGridlineStroke = FastScatterPlot.DEFAULT_GRIDLINE_STROKE; | |
| 223 | ||
| 224 | } | |
| 225 | ||
| 226 | /** | |
| 227 | * Returns a short string describing the plot type. | |
| 228 | * | |
| 229 | * @return A short string describing the plot type. | |
| 230 | */ | |
| 231 | public String getPlotType() { | |
| 232 |
1
1. getPlotType : mutated return of Object value for org/jfree/chart/plot/FastScatterPlot::getPlotType to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return localizationResources.getString("Fast_Scatter_Plot"); |
| 233 | } | |
| 234 | ||
| 235 | /** | |
| 236 | * Returns the data array used by the plot. | |
| 237 | * | |
| 238 | * @return The data array (possibly null). | |
| 239 | * | |
| 240 | * @see #setData(float[][]) | |
| 241 | */ | |
| 242 | public float[][] getData() { | |
| 243 |
1
1. getData : mutated return of Object value for org/jfree/chart/plot/FastScatterPlot::getData to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return this.data; |
| 244 | } | |
| 245 | ||
| 246 | /** | |
| 247 | * Sets the data array used by the plot and sends a {@link PlotChangeEvent} | |
| 248 | * to all registered listeners. | |
| 249 | * | |
| 250 | * @param data the data array (null permitted). | |
| 251 | * | |
| 252 | * @see #getData() | |
| 253 | */ | |
| 254 | public void setData(float[][] data) { | |
| 255 | this.data = data; | |
| 256 |
1
1. setData : removed call to org/jfree/chart/plot/FastScatterPlot::fireChangeEvent → SURVIVED |
fireChangeEvent(); |
| 257 | } | |
| 258 | ||
| 259 | /** | |
| 260 | * Returns the orientation of the plot. | |
| 261 | * | |
| 262 | * @return The orientation (always {@link PlotOrientation#VERTICAL}). | |
| 263 | */ | |
| 264 | public PlotOrientation getOrientation() { | |
| 265 |
1
1. getOrientation : mutated return of Object value for org/jfree/chart/plot/FastScatterPlot::getOrientation to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return PlotOrientation.VERTICAL; |
| 266 | } | |
| 267 | ||
| 268 | /** | |
| 269 | * Returns the domain axis for the plot. | |
| 270 | * | |
| 271 | * @return The domain axis (never null). | |
| 272 | * | |
| 273 | * @see #setDomainAxis(ValueAxis) | |
| 274 | */ | |
| 275 | public ValueAxis getDomainAxis() { | |
| 276 |
1
1. getDomainAxis : mutated return of Object value for org/jfree/chart/plot/FastScatterPlot::getDomainAxis to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return this.domainAxis; |
| 277 | } | |
| 278 | ||
| 279 | /** | |
| 280 | * Sets the domain axis and sends a {@link PlotChangeEvent} to all | |
| 281 | * registered listeners. | |
| 282 | * | |
| 283 | * @param axis the axis (null not permitted). | |
| 284 | * | |
| 285 | * @since 1.0.3 | |
| 286 | * | |
| 287 | * @see #getDomainAxis() | |
| 288 | */ | |
| 289 | public void setDomainAxis(ValueAxis axis) { | |
| 290 |
1
1. setDomainAxis : negated conditional → NO_COVERAGE |
if (axis == null) { |
| 291 | throw new IllegalArgumentException("Null 'axis' argument."); | |
| 292 | } | |
| 293 | this.domainAxis = axis; | |
| 294 |
1
1. setDomainAxis : removed call to org/jfree/chart/plot/FastScatterPlot::fireChangeEvent → NO_COVERAGE |
fireChangeEvent(); |
| 295 | } | |
| 296 | ||
| 297 | /** | |
| 298 | * Returns the range axis for the plot. | |
| 299 | * | |
| 300 | * @return The range axis (never null). | |
| 301 | * | |
| 302 | * @see #setRangeAxis(ValueAxis) | |
| 303 | */ | |
| 304 | public ValueAxis getRangeAxis() { | |
| 305 |
1
1. getRangeAxis : mutated return of Object value for org/jfree/chart/plot/FastScatterPlot::getRangeAxis to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return this.rangeAxis; |
| 306 | } | |
| 307 | ||
| 308 | /** | |
| 309 | * Sets the range axis and sends a {@link PlotChangeEvent} to all | |
| 310 | * registered listeners. | |
| 311 | * | |
| 312 | * @param axis the axis (null not permitted). | |
| 313 | * | |
| 314 | * @since 1.0.3 | |
| 315 | * | |
| 316 | * @see #getRangeAxis() | |
| 317 | */ | |
| 318 | public void setRangeAxis(ValueAxis axis) { | |
| 319 |
1
1. setRangeAxis : negated conditional → NO_COVERAGE |
if (axis == null) { |
| 320 | throw new IllegalArgumentException("Null 'axis' argument."); | |
| 321 | } | |
| 322 | this.rangeAxis = axis; | |
| 323 |
1
1. setRangeAxis : removed call to org/jfree/chart/plot/FastScatterPlot::fireChangeEvent → NO_COVERAGE |
fireChangeEvent(); |
| 324 | } | |
| 325 | ||
| 326 | /** | |
| 327 | * Returns the paint used to plot data points. The default is | |
| 328 | * Color.red. | |
| 329 | * | |
| 330 | * @return The paint. | |
| 331 | * | |
| 332 | * @see #setPaint(Paint) | |
| 333 | */ | |
| 334 | public Paint getPaint() { | |
| 335 |
1
1. getPaint : mutated return of Object value for org/jfree/chart/plot/FastScatterPlot::getPaint to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return this.paint; |
| 336 | } | |
| 337 | ||
| 338 | /** | |
| 339 | * Sets the color for the data points and sends a {@link PlotChangeEvent} | |
| 340 | * to all registered listeners. | |
| 341 | * | |
| 342 | * @param paint the paint (null not permitted). | |
| 343 | * | |
| 344 | * @see #getPaint() | |
| 345 | */ | |
| 346 | public void setPaint(Paint paint) { | |
| 347 |
1
1. setPaint : negated conditional → KILLED |
if (paint == null) { |
| 348 | throw new IllegalArgumentException("Null 'paint' argument."); | |
| 349 | } | |
| 350 | this.paint = paint; | |
| 351 |
1
1. setPaint : removed call to org/jfree/chart/plot/FastScatterPlot::fireChangeEvent → SURVIVED |
fireChangeEvent(); |
| 352 | } | |
| 353 | ||
| 354 | /** | |
| 355 | * Returns true if the domain gridlines are visible, and | |
| 356 | * false otherwise. | |
| 357 | * | |
| 358 | * @return true or false. | |
| 359 | * | |
| 360 | * @see #setDomainGridlinesVisible(boolean) | |
| 361 | * @see #setDomainGridlinePaint(Paint) | |
| 362 | */ | |
| 363 | public boolean isDomainGridlinesVisible() { | |
| 364 |
1
1. isDomainGridlinesVisible : replaced return of integer sized value with (x == 0 ? 1 : 0) → SURVIVED |
return this.domainGridlinesVisible; |
| 365 | } | |
| 366 | ||
| 367 | /** | |
| 368 | * Sets the flag that controls whether or not the domain grid-lines are | |
| 369 | * visible. If the flag value is changed, a {@link PlotChangeEvent} is | |
| 370 | * sent to all registered listeners. | |
| 371 | * | |
| 372 | * @param visible the new value of the flag. | |
| 373 | * | |
| 374 | * @see #getDomainGridlinePaint() | |
| 375 | */ | |
| 376 | public void setDomainGridlinesVisible(boolean visible) { | |
| 377 |
1
1. setDomainGridlinesVisible : negated conditional → KILLED |
if (this.domainGridlinesVisible != visible) { |
| 378 | this.domainGridlinesVisible = visible; | |
| 379 |
1
1. setDomainGridlinesVisible : removed call to org/jfree/chart/plot/FastScatterPlot::fireChangeEvent → SURVIVED |
fireChangeEvent(); |
| 380 | } | |
| 381 | } | |
| 382 | ||
| 383 | /** | |
| 384 | * Returns the stroke for the grid-lines (if any) plotted against the | |
| 385 | * domain axis. | |
| 386 | * | |
| 387 | * @return The stroke (never null). | |
| 388 | * | |
| 389 | * @see #setDomainGridlineStroke(Stroke) | |
| 390 | */ | |
| 391 | public Stroke getDomainGridlineStroke() { | |
| 392 |
1
1. getDomainGridlineStroke : mutated return of Object value for org/jfree/chart/plot/FastScatterPlot::getDomainGridlineStroke to ( if (x != null) null else throw new RuntimeException ) → KILLED |
return this.domainGridlineStroke; |
| 393 | } | |
| 394 | ||
| 395 | /** | |
| 396 | * Sets the stroke for the grid lines plotted against the domain axis and | |
| 397 | * sends a {@link PlotChangeEvent} to all registered listeners. | |
| 398 | * | |
| 399 | * @param stroke the stroke (null not permitted). | |
| 400 | * | |
| 401 | * @see #getDomainGridlineStroke() | |
| 402 | */ | |
| 403 | public void setDomainGridlineStroke(Stroke stroke) { | |
| 404 |
1
1. setDomainGridlineStroke : negated conditional → KILLED |
if (stroke == null) { |
| 405 | throw new IllegalArgumentException("Null 'stroke' argument."); | |
| 406 | } | |
| 407 | this.domainGridlineStroke = stroke; | |
| 408 |
1
1. setDomainGridlineStroke : removed call to org/jfree/chart/plot/FastScatterPlot::fireChangeEvent → SURVIVED |
fireChangeEvent(); |
| 409 | } | |
| 410 | ||
| 411 | /** | |
| 412 | * Returns the paint for the grid lines (if any) plotted against the domain | |
| 413 | * axis. | |
| 414 | * | |
| 415 | * @return The paint (never null). | |
| 416 | * | |
| 417 | * @see #setDomainGridlinePaint(Paint) | |
| 418 | */ | |
| 419 | public Paint getDomainGridlinePaint() { | |
| 420 |
1
1. getDomainGridlinePaint : mutated return of Object value for org/jfree/chart/plot/FastScatterPlot::getDomainGridlinePaint to ( if (x != null) null else throw new RuntimeException ) → SURVIVED |
return this.domainGridlinePaint; |
| 421 | } | |
| 422 | ||
| 423 | /** | |
| 424 | * Sets the paint for the grid lines plotted against the domain axis and | |
| 425 | * sends a {@link PlotChangeEvent} to all registered listeners. | |
| 426 | * | |
| 427 | * @param paint the paint (null not permitted). | |
| 428 | * | |
| 429 | * @see #getDomainGridlinePaint() | |
| 430 | */ | |
| 431 | public void setDomainGridlinePaint(Paint paint) { | |
| 432 |
1
1. setDomainGridlinePaint : negated conditional → KILLED |
if (paint == null) { |
| 433 | throw new IllegalArgumentException("Null 'paint' argument."); | |
| 434 | } | |
| 435 | this.domainGridlinePaint = paint; | |
| 436 |
1
1. setDomainGridlinePaint : removed call to org/jfree/chart/plot/FastScatterPlot::fireChangeEvent → SURVIVED |
fireChangeEvent(); |
| 437 | } | |
| 438 | ||
| 439 | /** | |
| 440 | * Returns true if the range axis grid is visible, and | |
| 441 | * false otherwise. | |
| 442 | * | |
| 443 | * @return true or false. | |
| 444 | * | |
| 445 | * @see #setRangeGridlinesVisible(boolean) | |
| 446 | */ | |
| 447 | public boolean isRangeGridlinesVisible() { | |
| 448 |
1
1. isRangeGridlinesVisible : replaced return of integer sized value with (x == 0 ? 1 : 0) → SURVIVED |
return this.rangeGridlinesVisible; |
| 449 | } | |
| 450 | ||
| 451 | /** | |
| 452 | * Sets the flag that controls whether or not the range axis grid lines are | |
| 453 | * visible. If the flag value is changed, a {@link PlotChangeEvent} is | |
| 454 | * sent to all registered listeners. | |
| 455 | * | |
| 456 | * @param visible the new value of the flag. | |
| 457 | * | |
| 458 | * @see #isRangeGridlinesVisible() | |
| 459 | */ | |
| 460 | public void setRangeGridlinesVisible(boolean visible) { | |
| 461 |
1
1. setRangeGridlinesVisible : negated conditional → KILLED |
if (this.rangeGridlinesVisible != visible) { |
| 462 | this.rangeGridlinesVisible = visible; | |
| 463 |
1
1. setRangeGridlinesVisible : removed call to org/jfree/chart/plot/FastScatterPlot::fireChangeEvent → SURVIVED |
fireChangeEvent(); |
| 464 | } | |
| 465 | } | |
| 466 | ||
| 467 | /** | |
| 468 | * Returns the stroke for the grid lines (if any) plotted against the range | |
| 469 | * axis. | |
| 470 | * | |
| 471 | * @return The stroke (never null). | |
| 472 | * | |
| 473 | * @see #setRangeGridlineStroke(Stroke) | |
| 474 | */ | |
| 475 | public Stroke getRangeGridlineStroke() { | |
| 476 |
1
1. getRangeGridlineStroke : mutated return of Object value for org/jfree/chart/plot/FastScatterPlot::getRangeGridlineStroke to ( if (x != null) null else throw new RuntimeException ) → KILLED |
return this.rangeGridlineStroke; |
| 477 | } | |
| 478 | ||
| 479 | /** | |
| 480 | * Sets the stroke for the grid lines plotted against the range axis and | |
| 481 | * sends a {@link PlotChangeEvent} to all registered listeners. | |
| 482 | * | |
| 483 | * @param stroke the stroke (null permitted). | |
| 484 | * | |
| 485 | * @see #getRangeGridlineStroke() | |
| 486 | */ | |
| 487 | public void setRangeGridlineStroke(Stroke stroke) { | |
| 488 |
1
1. setRangeGridlineStroke : negated conditional → KILLED |
if (stroke == null) { |
| 489 | throw new IllegalArgumentException("Null 'stroke' argument."); | |
| 490 | } | |
| 491 | this.rangeGridlineStroke = stroke; | |
| 492 |
1
1. setRangeGridlineStroke : removed call to org/jfree/chart/plot/FastScatterPlot::fireChangeEvent → SURVIVED |
fireChangeEvent(); |
| 493 | } | |
| 494 | ||
| 495 | /** | |
| 496 | * Returns the paint for the grid lines (if any) plotted against the range | |
| 497 | * axis. | |
| 498 | * | |
| 499 | * @return The paint (never null). | |
| 500 | * | |
| 501 | * @see #setRangeGridlinePaint(Paint) | |
| 502 | */ | |
| 503 | public Paint getRangeGridlinePaint() { | |
| 504 |
1
1. getRangeGridlinePaint : mutated return of Object value for org/jfree/chart/plot/FastScatterPlot::getRangeGridlinePaint to ( if (x != null) null else throw new RuntimeException ) → SURVIVED |
return this.rangeGridlinePaint; |
| 505 | } | |
| 506 | ||
| 507 | /** | |
| 508 | * Sets the paint for the grid lines plotted against the range axis and | |
| 509 | * sends a {@link PlotChangeEvent} to all registered listeners. | |
| 510 | * | |
| 511 | * @param paint the paint (null not permitted). | |
| 512 | * | |
| 513 | * @see #getRangeGridlinePaint() | |
| 514 | */ | |
| 515 | public void setRangeGridlinePaint(Paint paint) { | |
| 516 |
1
1. setRangeGridlinePaint : negated conditional → KILLED |
if (paint == null) { |
| 517 | throw new IllegalArgumentException("Null 'paint' argument."); | |
| 518 | } | |
| 519 | this.rangeGridlinePaint = paint; | |
| 520 |
1
1. setRangeGridlinePaint : removed call to org/jfree/chart/plot/FastScatterPlot::fireChangeEvent → SURVIVED |
fireChangeEvent(); |
| 521 | } | |
| 522 | ||
| 523 | /** | |
| 524 | * Draws the fast scatter plot on a Java 2D graphics device (such as the | |
| 525 | * screen or a printer). | |
| 526 | * | |
| 527 | * @param g2 the graphics device. | |
| 528 | * @param area the area within which the plot (including axis labels) | |
| 529 | * should be drawn. | |
| 530 | * @param anchor the anchor point (null permitted). | |
| 531 | * @param parentState the state from the parent plot (ignored). | |
| 532 | * @param info collects chart drawing information (null | |
| 533 | * permitted). | |
| 534 | */ | |
| 535 | public void draw(Graphics2D g2, Rectangle2D area, Point2D anchor, | |
| 536 | PlotState parentState, | |
| 537 | PlotRenderingInfo info) { | |
| 538 | ||
| 539 | // set up info collection... | |
| 540 |
1
1. draw : negated conditional → KILLED |
if (info != null) { |
| 541 |
1
1. draw : removed call to org/jfree/chart/plot/PlotRenderingInfo::setPlotArea → NO_COVERAGE |
info.setPlotArea(area); |
| 542 | } | |
| 543 | ||
| 544 | // adjust the drawing area for plot insets (if any)... | |
| 545 | RectangleInsets insets = getInsets(); | |
| 546 |
1
1. draw : removed call to org/jfree/chart/util/RectangleInsets::trim → SURVIVED |
insets.trim(area); |
| 547 | ||
| 548 | AxisSpace space = new AxisSpace(); | |
| 549 | space = this.domainAxis.reserveSpace(g2, this, area, | |
| 550 | RectangleEdge.BOTTOM, space); | |
| 551 | space = this.rangeAxis.reserveSpace(g2, this, area, RectangleEdge.LEFT, | |
| 552 | space); | |
| 553 | Rectangle2D dataArea = space.shrink(area, null); | |
| 554 | ||
| 555 |
1
1. draw : negated conditional → KILLED |
if (info != null) { |
| 556 |
1
1. draw : removed call to org/jfree/chart/plot/PlotRenderingInfo::setDataArea → NO_COVERAGE |
info.setDataArea(dataArea); |
| 557 | } | |
| 558 | ||
| 559 | // draw the plot background and axes... | |
| 560 |
1
1. draw : removed call to org/jfree/chart/plot/FastScatterPlot::drawBackground → SURVIVED |
drawBackground(g2, dataArea); |
| 561 | ||
| 562 | AxisState domainAxisState = this.domainAxis.draw(g2, | |
| 563 | dataArea.getMaxY(), area, dataArea, RectangleEdge.BOTTOM, info); | |
| 564 | AxisState rangeAxisState = this.rangeAxis.draw(g2, dataArea.getMinX(), | |
| 565 | area, dataArea, RectangleEdge.LEFT, info); | |
| 566 |
1
1. draw : removed call to org/jfree/chart/plot/FastScatterPlot::drawDomainGridlines → SURVIVED |
drawDomainGridlines(g2, dataArea, domainAxisState.getTicks()); |
| 567 |
1
1. draw : removed call to org/jfree/chart/plot/FastScatterPlot::drawRangeGridlines → SURVIVED |
drawRangeGridlines(g2, dataArea, rangeAxisState.getTicks()); |
| 568 | ||
| 569 | Shape originalClip = g2.getClip(); | |
| 570 | Composite originalComposite = g2.getComposite(); | |
| 571 | ||
| 572 |
1
1. draw : removed call to java/awt/Graphics2D::clip → SURVIVED |
g2.clip(dataArea); |
| 573 |
1
1. draw : removed call to java/awt/Graphics2D::setComposite → SURVIVED |
g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, |
| 574 | getForegroundAlpha())); | |
| 575 | ||
| 576 |
1
1. draw : removed call to org/jfree/chart/plot/FastScatterPlot::render → SURVIVED |
render(g2, dataArea, info, null); |
| 577 | ||
| 578 |
1
1. draw : removed call to java/awt/Graphics2D::setClip → SURVIVED |
g2.setClip(originalClip); |
| 579 |
1
1. draw : removed call to java/awt/Graphics2D::setComposite → SURVIVED |
g2.setComposite(originalComposite); |
| 580 |
1
1. draw : removed call to org/jfree/chart/plot/FastScatterPlot::drawOutline → SURVIVED |
drawOutline(g2, dataArea); |
| 581 | ||
| 582 | } | |
| 583 | ||
| 584 | /** | |
| 585 | * Draws a representation of the data within the dataArea region. The | |
| 586 | * info and crosshairState arguments may be | |
| 587 | * null. | |
| 588 | * | |
| 589 | * @param g2 the graphics device. | |
| 590 | * @param dataArea the region in which the data is to be drawn. | |
| 591 | * @param info an optional object for collection dimension information. | |
| 592 | * @param crosshairState collects crosshair information (null | |
| 593 | * permitted). | |
| 594 | */ | |
| 595 | public void render(Graphics2D g2, Rectangle2D dataArea, | |
| 596 | PlotRenderingInfo info, CrosshairState crosshairState) { | |
| 597 | ||
| 598 | ||
| 599 | //long start = System.currentTimeMillis(); | |
| 600 | //System.out.println("Start: " + start); | |
| 601 |
1
1. render : removed call to java/awt/Graphics2D::setPaint → SURVIVED |
g2.setPaint(this.paint); |
| 602 | ||
| 603 | // if the axes use a linear scale, you can uncomment the code below and | |
| 604 | // switch to the alternative transX/transY calculation inside the loop | |
| 605 | // that follows - it is a little bit faster then. | |
| 606 | // | |
| 607 | // int xx = (int) dataArea.getMinX(); | |
| 608 | // int ww = (int) dataArea.getWidth(); | |
| 609 | // int yy = (int) dataArea.getMaxY(); | |
| 610 | // int hh = (int) dataArea.getHeight(); | |
| 611 | // double domainMin = this.domainAxis.getLowerBound(); | |
| 612 | // double domainLength = this.domainAxis.getUpperBound() - domainMin; | |
| 613 | // double rangeMin = this.rangeAxis.getLowerBound(); | |
| 614 | // double rangeLength = this.rangeAxis.getUpperBound() - rangeMin; | |
| 615 | ||
| 616 |
1
1. render : negated conditional → SURVIVED |
if (this.data != null) { |
| 617 |
3
1. render : negated conditional → SURVIVED 2. render : changed conditional boundary → KILLED 3. render : Changed increment from 1 to -1 → KILLED |
for (int i = 0; i < this.data[0].length; i++) { |
| 618 | float x = this.data[0][i]; | |
| 619 | float y = this.data[1][i]; | |
| 620 | ||
| 621 | //int transX = (int) (xx + ww * (x - domainMin) / domainLength); | |
| 622 | //int transY = (int) (yy - hh * (y - rangeMin) / rangeLength); | |
| 623 | int transX = (int) this.domainAxis.valueToJava2D(x, dataArea, | |
| 624 | RectangleEdge.BOTTOM); | |
| 625 | int transY = (int) this.rangeAxis.valueToJava2D(y, dataArea, | |
| 626 | RectangleEdge.LEFT); | |
| 627 |
1
1. render : removed call to java/awt/Graphics2D::fillRect → SURVIVED |
g2.fillRect(transX, transY, 1, 1); |
| 628 | } | |
| 629 | } | |
| 630 | //long finish = System.currentTimeMillis(); | |
| 631 | //System.out.println("Finish: " + finish); | |
| 632 | //System.out.println("Time: " + (finish - start)); | |
| 633 | ||
| 634 | } | |
| 635 | ||
| 636 | /** | |
| 637 | * Draws the gridlines for the plot, if they are visible. | |
| 638 | * | |
| 639 | * @param g2 the graphics device. | |
| 640 | * @param dataArea the data area. | |
| 641 | * @param ticks the ticks. | |
| 642 | */ | |
| 643 | protected void drawDomainGridlines(Graphics2D g2, Rectangle2D dataArea, | |
| 644 | List ticks) { | |
| 645 | ||
| 646 | // draw the domain grid lines, if the flag says they're visible... | |
| 647 |
1
1. drawDomainGridlines : negated conditional → SURVIVED |
if (isDomainGridlinesVisible()) { |
| 648 | Iterator iterator = ticks.iterator(); | |
| 649 |
1
1. drawDomainGridlines : negated conditional → SURVIVED |
while (iterator.hasNext()) { |
| 650 | ValueTick tick = (ValueTick) iterator.next(); | |
| 651 | double v = this.domainAxis.valueToJava2D(tick.getValue(), | |
| 652 | dataArea, RectangleEdge.BOTTOM); | |
| 653 | Line2D line = new Line2D.Double(v, dataArea.getMinY(), v, | |
| 654 | dataArea.getMaxY()); | |
| 655 |
1
1. drawDomainGridlines : removed call to java/awt/Graphics2D::setPaint → SURVIVED |
g2.setPaint(getDomainGridlinePaint()); |
| 656 |
1
1. drawDomainGridlines : removed call to java/awt/Graphics2D::setStroke → SURVIVED |
g2.setStroke(getDomainGridlineStroke()); |
| 657 |
1
1. drawDomainGridlines : removed call to java/awt/Graphics2D::draw → SURVIVED |
g2.draw(line); |
| 658 | } | |
| 659 | } | |
| 660 | } | |
| 661 | ||
| 662 | /** | |
| 663 | * Draws the gridlines for the plot, if they are visible. | |
| 664 | * | |
| 665 | * @param g2 the graphics device. | |
| 666 | * @param dataArea the data area. | |
| 667 | * @param ticks the ticks. | |
| 668 | */ | |
| 669 | protected void drawRangeGridlines(Graphics2D g2, Rectangle2D dataArea, | |
| 670 | List ticks) { | |
| 671 | ||
| 672 | // draw the range grid lines, if the flag says they're visible... | |
| 673 |
1
1. drawRangeGridlines : negated conditional → SURVIVED |
if (isRangeGridlinesVisible()) { |
| 674 | Iterator iterator = ticks.iterator(); | |
| 675 |
1
1. drawRangeGridlines : negated conditional → SURVIVED |
while (iterator.hasNext()) { |
| 676 | ValueTick tick = (ValueTick) iterator.next(); | |
| 677 | double v = this.rangeAxis.valueToJava2D(tick.getValue(), | |
| 678 | dataArea, RectangleEdge.LEFT); | |
| 679 | Line2D line = new Line2D.Double(dataArea.getMinX(), v, | |
| 680 | dataArea.getMaxX(), v); | |
| 681 |
1
1. drawRangeGridlines : removed call to java/awt/Graphics2D::setPaint → SURVIVED |
g2.setPaint(getRangeGridlinePaint()); |
| 682 |
1
1. drawRangeGridlines : removed call to java/awt/Graphics2D::setStroke → SURVIVED |
g2.setStroke(getRangeGridlineStroke()); |
| 683 |
1
1. drawRangeGridlines : removed call to java/awt/Graphics2D::draw → SURVIVED |
g2.draw(line); |
| 684 | } | |
| 685 | } | |
| 686 | ||
| 687 | } | |
| 688 | ||
| 689 | /** | |
| 690 | * Returns the range of data values to be plotted along the axis, or | |
| 691 | * null if the specified axis isn't the domain axis or the | |
| 692 | * range axis for the plot. | |
| 693 | * | |
| 694 | * @param axis the axis (null permitted). | |
| 695 | * | |
| 696 | * @return The range (possibly null). | |
| 697 | */ | |
| 698 | public Range getDataRange(ValueAxis axis) { | |
| 699 | Range result = null; | |
| 700 |
1
1. getDataRange : negated conditional → SURVIVED |
if (axis == this.domainAxis) { |
| 701 | result = this.xDataRange; | |
| 702 | } | |
| 703 |
1
1. getDataRange : negated conditional → SURVIVED |
else if (axis == this.rangeAxis) { |
| 704 | result = this.yDataRange; | |
| 705 | } | |
| 706 |
1
1. getDataRange : mutated return of Object value for org/jfree/chart/plot/FastScatterPlot::getDataRange to ( if (x != null) null else throw new RuntimeException ) → KILLED |
return result; |
| 707 | } | |
| 708 | ||
| 709 | /** | |
| 710 | * Calculates the X data range. | |
| 711 | * | |
| 712 | * @param data the data (null permitted). | |
| 713 | * | |
| 714 | * @return The range. | |
| 715 | */ | |
| 716 | private Range calculateXDataRange(float[][] data) { | |
| 717 | ||
| 718 | Range result = null; | |
| 719 | ||
| 720 |
1
1. calculateXDataRange : negated conditional → KILLED |
if (data != null) { |
| 721 | float lowest = Float.POSITIVE_INFINITY; | |
| 722 | float highest = Float.NEGATIVE_INFINITY; | |
| 723 |
3
1. calculateXDataRange : negated conditional → SURVIVED 2. calculateXDataRange : changed conditional boundary → KILLED 3. calculateXDataRange : Changed increment from 1 to -1 → KILLED |
for (int i = 0; i < data[0].length; i++) { |
| 724 | float v = data[0][i]; | |
| 725 |
2
1. calculateXDataRange : changed conditional boundary → SURVIVED 2. calculateXDataRange : negated conditional → SURVIVED |
if (v < lowest) { |
| 726 | lowest = v; | |
| 727 | } | |
| 728 |
2
1. calculateXDataRange : changed conditional boundary → SURVIVED 2. calculateXDataRange : negated conditional → SURVIVED |
if (v > highest) { |
| 729 | highest = v; | |
| 730 | } | |
| 731 | } | |
| 732 |
2
1. calculateXDataRange : changed conditional boundary → SURVIVED 2. calculateXDataRange : negated conditional → SURVIVED |
if (lowest <= highest) { |
| 733 | result = new Range(lowest, highest); | |
| 734 | } | |
| 735 | } | |
| 736 | ||
| 737 |
1
1. calculateXDataRange : mutated return of Object value for org/jfree/chart/plot/FastScatterPlot::calculateXDataRange to ( if (x != null) null else throw new RuntimeException ) → KILLED |
return result; |
| 738 | ||
| 739 | } | |
| 740 | ||
| 741 | /** | |
| 742 | * Calculates the Y data range. | |
| 743 | * | |
| 744 | * @param data the data (null permitted). | |
| 745 | * | |
| 746 | * @return The range. | |
| 747 | */ | |
| 748 | private Range calculateYDataRange(float[][] data) { | |
| 749 | ||
| 750 | Range result = null; | |
| 751 | ||
| 752 |
1
1. calculateYDataRange : negated conditional → KILLED |
if (data != null) { |
| 753 | float lowest = Float.POSITIVE_INFINITY; | |
| 754 | float highest = Float.NEGATIVE_INFINITY; | |
| 755 |
3
1. calculateYDataRange : negated conditional → SURVIVED 2. calculateYDataRange : changed conditional boundary → KILLED 3. calculateYDataRange : Changed increment from 1 to -1 → KILLED |
for (int i = 0; i < data[0].length; i++) { |
| 756 | float v = data[1][i]; | |
| 757 |
2
1. calculateYDataRange : changed conditional boundary → SURVIVED 2. calculateYDataRange : negated conditional → SURVIVED |
if (v < lowest) { |
| 758 | lowest = v; | |
| 759 | } | |
| 760 |
2
1. calculateYDataRange : changed conditional boundary → SURVIVED 2. calculateYDataRange : negated conditional → SURVIVED |
if (v > highest) { |
| 761 | highest = v; | |
| 762 | } | |
| 763 | } | |
| 764 |
2
1. calculateYDataRange : changed conditional boundary → SURVIVED 2. calculateYDataRange : negated conditional → SURVIVED |
if (lowest <= highest) { |
| 765 | result = new Range(lowest, highest); | |
| 766 | } | |
| 767 | } | |
| 768 |
1
1. calculateYDataRange : mutated return of Object value for org/jfree/chart/plot/FastScatterPlot::calculateYDataRange to ( if (x != null) null else throw new RuntimeException ) → KILLED |
return result; |
| 769 | ||
| 770 | } | |
| 771 | ||
| 772 | /** | |
| 773 | * Multiplies the range on the domain axis by the specified factor. | |
| 774 | * | |
| 775 | * @param factor the zoom factor. | |
| 776 | * @param info the plot rendering info. | |
| 777 | * @param source the source point. | |
| 778 | */ | |
| 779 | public void zoomDomainAxes(double factor, PlotRenderingInfo info, | |
| 780 | Point2D source) { | |
| 781 |
1
1. zoomDomainAxes : removed call to org/jfree/chart/axis/ValueAxis::resizeRange → NO_COVERAGE |
this.domainAxis.resizeRange(factor); |
| 782 | } | |
| 783 | ||
| 784 | /** | |
| 785 | * Multiplies the range on the domain axis by the specified factor. | |
| 786 | * | |
| 787 | * @param factor the zoom factor. | |
| 788 | * @param info the plot rendering info. | |
| 789 | * @param source the source point (in Java2D space). | |
| 790 | * @param useAnchor use source point as zoom anchor? | |
| 791 | * | |
| 792 | * @see #zoomRangeAxes(double, PlotRenderingInfo, Point2D, boolean) | |
| 793 | * | |
| 794 | * @since 1.0.7 | |
| 795 | */ | |
| 796 | public void zoomDomainAxes(double factor, PlotRenderingInfo info, | |
| 797 | Point2D source, boolean useAnchor) { | |
| 798 | ||
| 799 |
1
1. zoomDomainAxes : negated conditional → NO_COVERAGE |
if (useAnchor) { |
| 800 | // get the source coordinate - this plot has always a VERTICAL | |
| 801 | // orientation | |
| 802 | double sourceX = source.getX(); | |
| 803 | double anchorX = this.domainAxis.java2DToValue(sourceX, | |
| 804 | info.getDataArea(), RectangleEdge.BOTTOM); | |
| 805 |
1
1. zoomDomainAxes : removed call to org/jfree/chart/axis/ValueAxis::resizeRange2 → NO_COVERAGE |
this.domainAxis.resizeRange2(factor, anchorX); |
| 806 | } | |
| 807 | else { | |
| 808 |
1
1. zoomDomainAxes : removed call to org/jfree/chart/axis/ValueAxis::resizeRange → NO_COVERAGE |
this.domainAxis.resizeRange(factor); |
| 809 | } | |
| 810 | ||
| 811 | } | |
| 812 | ||
| 813 | /** | |
| 814 | * Zooms in on the domain axes. | |
| 815 | * | |
| 816 | * @param lowerPercent the new lower bound as a percentage of the current | |
| 817 | * range. | |
| 818 | * @param upperPercent the new upper bound as a percentage of the current | |
| 819 | * range. | |
| 820 | * @param info the plot rendering info. | |
| 821 | * @param source the source point. | |
| 822 | */ | |
| 823 | public void zoomDomainAxes(double lowerPercent, double upperPercent, | |
| 824 | PlotRenderingInfo info, Point2D source) { | |
| 825 |
1
1. zoomDomainAxes : removed call to org/jfree/chart/axis/ValueAxis::zoomRange → NO_COVERAGE |
this.domainAxis.zoomRange(lowerPercent, upperPercent); |
| 826 | } | |
| 827 | ||
| 828 | /** | |
| 829 | * Multiplies the range on the range axis/axes by the specified factor. | |
| 830 | * | |
| 831 | * @param factor the zoom factor. | |
| 832 | * @param info the plot rendering info. | |
| 833 | * @param source the source point. | |
| 834 | */ | |
| 835 | public void zoomRangeAxes(double factor, | |
| 836 | PlotRenderingInfo info, Point2D source) { | |
| 837 |
1
1. zoomRangeAxes : removed call to org/jfree/chart/axis/ValueAxis::resizeRange → NO_COVERAGE |
this.rangeAxis.resizeRange(factor); |
| 838 | } | |
| 839 | ||
| 840 | /** | |
| 841 | * Multiplies the range on the range axis by the specified factor. | |
| 842 | * | |
| 843 | * @param factor the zoom factor. | |
| 844 | * @param info the plot rendering info. | |
| 845 | * @param source the source point (in Java2D space). | |
| 846 | * @param useAnchor use source point as zoom anchor? | |
| 847 | * | |
| 848 | * @see #zoomDomainAxes(double, PlotRenderingInfo, Point2D, boolean) | |
| 849 | * | |
| 850 | * @since 1.0.7 | |
| 851 | */ | |
| 852 | public void zoomRangeAxes(double factor, PlotRenderingInfo info, | |
| 853 | Point2D source, boolean useAnchor) { | |
| 854 | ||
| 855 |
1
1. zoomRangeAxes : negated conditional → NO_COVERAGE |
if (useAnchor) { |
| 856 | // get the source coordinate - this plot has always a VERTICAL | |
| 857 | // orientation | |
| 858 | double sourceY = source.getY(); | |
| 859 | double anchorY = this.rangeAxis.java2DToValue(sourceY, | |
| 860 | info.getDataArea(), RectangleEdge.LEFT); | |
| 861 |
1
1. zoomRangeAxes : removed call to org/jfree/chart/axis/ValueAxis::resizeRange2 → NO_COVERAGE |
this.rangeAxis.resizeRange2(factor, anchorY); |
| 862 | } | |
| 863 | else { | |
| 864 |
1
1. zoomRangeAxes : removed call to org/jfree/chart/axis/ValueAxis::resizeRange → NO_COVERAGE |
this.rangeAxis.resizeRange(factor); |
| 865 | } | |
| 866 | ||
| 867 | } | |
| 868 | ||
| 869 | /** | |
| 870 | * Zooms in on the range axes. | |
| 871 | * | |
| 872 | * @param lowerPercent the new lower bound as a percentage of the current | |
| 873 | * range. | |
| 874 | * @param upperPercent the new upper bound as a percentage of the current | |
| 875 | * range. | |
| 876 | * @param info the plot rendering info. | |
| 877 | * @param source the source point. | |
| 878 | */ | |
| 879 | public void zoomRangeAxes(double lowerPercent, double upperPercent, | |
| 880 | PlotRenderingInfo info, Point2D source) { | |
| 881 |
1
1. zoomRangeAxes : removed call to org/jfree/chart/axis/ValueAxis::zoomRange → NO_COVERAGE |
this.rangeAxis.zoomRange(lowerPercent, upperPercent); |
| 882 | } | |
| 883 | ||
| 884 | /** | |
| 885 | * Returns true. | |
| 886 | * | |
| 887 | * @return A boolean. | |
| 888 | */ | |
| 889 | public boolean isDomainZoomable() { | |
| 890 |
1
1. isDomainZoomable : replaced return of integer sized value with (x == 0 ? 1 : 0) → NO_COVERAGE |
return true; |
| 891 | } | |
| 892 | ||
| 893 | /** | |
| 894 | * Returns true. | |
| 895 | * | |
| 896 | * @return A boolean. | |
| 897 | */ | |
| 898 | public boolean isRangeZoomable() { | |
| 899 |
1
1. isRangeZoomable : replaced return of integer sized value with (x == 0 ? 1 : 0) → NO_COVERAGE |
return true; |
| 900 | } | |
| 901 | ||
| 902 | /** | |
| 903 | * Returns true if panning is enabled for the domain axes, | |
| 904 | * and false otherwise. | |
| 905 | * | |
| 906 | * @return A boolean. | |
| 907 | * | |
| 908 | * @since 1.0.13 | |
| 909 | */ | |
| 910 | public boolean isDomainPannable() { | |
| 911 |
1
1. isDomainPannable : replaced return of integer sized value with (x == 0 ? 1 : 0) → NO_COVERAGE |
return this.domainPannable; |
| 912 | } | |
| 913 | ||
| 914 | /** | |
| 915 | * Sets the flag that enables or disables panning of the plot along the | |
| 916 | * domain axes. | |
| 917 | * | |
| 918 | * @param pannable the new flag value. | |
| 919 | * | |
| 920 | * @since 1.0.13 | |
| 921 | */ | |
| 922 | public void setDomainPannable(boolean pannable) { | |
| 923 | this.domainPannable = pannable; | |
| 924 | } | |
| 925 | ||
| 926 | /** | |
| 927 | * Returns true if panning is enabled for the range axes, | |
| 928 | * and false otherwise. | |
| 929 | * | |
| 930 | * @return A boolean. | |
| 931 | * | |
| 932 | * @since 1.0.13 | |
| 933 | */ | |
| 934 | public boolean isRangePannable() { | |
| 935 |
1
1. isRangePannable : replaced return of integer sized value with (x == 0 ? 1 : 0) → NO_COVERAGE |
return this.rangePannable; |
| 936 | } | |
| 937 | ||
| 938 | /** | |
| 939 | * Sets the flag that enables or disables panning of the plot along | |
| 940 | * the range axes. | |
| 941 | * | |
| 942 | * @param pannable the new flag value. | |
| 943 | * | |
| 944 | * @since 1.0.13 | |
| 945 | */ | |
| 946 | public void setRangePannable(boolean pannable) { | |
| 947 | this.rangePannable = pannable; | |
| 948 | } | |
| 949 | ||
| 950 | /** | |
| 951 | * Pans the domain axes by the specified percentage. | |
| 952 | * | |
| 953 | * @param percent the distance to pan (as a percentage of the axis length). | |
| 954 | * @param info the plot info | |
| 955 | * @param source the source point where the pan action started. | |
| 956 | * | |
| 957 | * @since 1.0.13 | |
| 958 | */ | |
| 959 | public void panDomainAxes(double percent, PlotRenderingInfo info, | |
| 960 | Point2D source) { | |
| 961 |
2
1. panDomainAxes : negated conditional → NO_COVERAGE 2. panDomainAxes : negated conditional → NO_COVERAGE |
if (!isDomainPannable() || this.domainAxis == null) { |
| 962 | return; | |
| 963 | } | |
| 964 | double length = this.domainAxis.getRange().getLength(); | |
| 965 |
2
1. panDomainAxes : removed negation → NO_COVERAGE 2. panDomainAxes : Replaced double multiplication with division → NO_COVERAGE |
double adj = -percent * length; |
| 966 |
1
1. panDomainAxes : negated conditional → NO_COVERAGE |
if (this.domainAxis.isInverted()) { |
| 967 |
1
1. panDomainAxes : removed negation → NO_COVERAGE |
adj = -adj; |
| 968 | } | |
| 969 |
3
1. panDomainAxes : Replaced double addition with subtraction → NO_COVERAGE 2. panDomainAxes : Replaced double addition with subtraction → NO_COVERAGE 3. panDomainAxes : removed call to org/jfree/chart/axis/ValueAxis::setRange → NO_COVERAGE |
this.domainAxis.setRange(this.domainAxis.getLowerBound() + adj, |
| 970 | this.domainAxis.getUpperBound() + adj); | |
| 971 | } | |
| 972 | ||
| 973 | /** | |
| 974 | * Pans the range axes by the specified percentage. | |
| 975 | * | |
| 976 | * @param percent the distance to pan (as a percentage of the axis length). | |
| 977 | * @param info the plot info | |
| 978 | * @param source the source point where the pan action started. | |
| 979 | * | |
| 980 | * @since 1.0.13 | |
| 981 | */ | |
| 982 | public void panRangeAxes(double percent, PlotRenderingInfo info, | |
| 983 | Point2D source) { | |
| 984 |
2
1. panRangeAxes : negated conditional → NO_COVERAGE 2. panRangeAxes : negated conditional → NO_COVERAGE |
if (!isRangePannable() || this.rangeAxis == null) { |
| 985 | return; | |
| 986 | } | |
| 987 | double length = this.rangeAxis.getRange().getLength(); | |
| 988 |
1
1. panRangeAxes : Replaced double multiplication with division → NO_COVERAGE |
double adj = percent * length; |
| 989 |
1
1. panRangeAxes : negated conditional → NO_COVERAGE |
if (this.rangeAxis.isInverted()) { |
| 990 |
1
1. panRangeAxes : removed negation → NO_COVERAGE |
adj = -adj; |
| 991 | } | |
| 992 |
3
1. panRangeAxes : Replaced double addition with subtraction → NO_COVERAGE 2. panRangeAxes : Replaced double addition with subtraction → NO_COVERAGE 3. panRangeAxes : removed call to org/jfree/chart/axis/ValueAxis::setRange → NO_COVERAGE |
this.rangeAxis.setRange(this.rangeAxis.getLowerBound() + adj, |
| 993 | this.rangeAxis.getUpperBound() + adj); | |
| 994 | } | |
| 995 | ||
| 996 | /** | |
| 997 | * Tests an arbitrary object for equality with this plot. Note that | |
| 998 | * FastScatterPlot carries its data around with it (rather | |
| 999 | * than referencing a dataset), and the data is included in the | |
| 1000 | * equality test. | |
| 1001 | * | |
| 1002 | * @param obj the object (null permitted). | |
| 1003 | * | |
| 1004 | * @return A boolean. | |
| 1005 | */ | |
| 1006 | public boolean equals(Object obj) { | |
| 1007 |
1
1. equals : negated conditional → KILLED |
if (obj == this) { |
| 1008 |
1
1. equals : replaced return of integer sized value with (x == 0 ? 1 : 0) → NO_COVERAGE |
return true; |
| 1009 | } | |
| 1010 |
1
1. equals : negated conditional → KILLED |
if (!super.equals(obj)) { |
| 1011 |
1
1. equals : replaced return of integer sized value with (x == 0 ? 1 : 0) → NO_COVERAGE |
return false; |
| 1012 | } | |
| 1013 |
1
1. equals : negated conditional → KILLED |
if (!(obj instanceof FastScatterPlot)) { |
| 1014 |
1
1. equals : replaced return of integer sized value with (x == 0 ? 1 : 0) → NO_COVERAGE |
return false; |
| 1015 | } | |
| 1016 | FastScatterPlot that = (FastScatterPlot) obj; | |
| 1017 |
1
1. equals : negated conditional → KILLED |
if (this.domainPannable != that.domainPannable) { |
| 1018 |
1
1. equals : replaced return of integer sized value with (x == 0 ? 1 : 0) → KILLED |
return false; |
| 1019 | } | |
| 1020 |
1
1. equals : negated conditional → KILLED |
if (this.rangePannable != that.rangePannable) { |
| 1021 |
1
1. equals : replaced return of integer sized value with (x == 0 ? 1 : 0) → KILLED |
return false; |
| 1022 | } | |
| 1023 |
1
1. equals : negated conditional → KILLED |
if (!ArrayUtilities.equal(this.data, that.data)) { |
| 1024 |
1
1. equals : replaced return of integer sized value with (x == 0 ? 1 : 0) → KILLED |
return false; |
| 1025 | } | |
| 1026 |
1
1. equals : negated conditional → KILLED |
if (!ObjectUtilities.equal(this.domainAxis, that.domainAxis)) { |
| 1027 |
1
1. equals : replaced return of integer sized value with (x == 0 ? 1 : 0) → NO_COVERAGE |
return false; |
| 1028 | } | |
| 1029 |
1
1. equals : negated conditional → KILLED |
if (!ObjectUtilities.equal(this.rangeAxis, that.rangeAxis)) { |
| 1030 |
1
1. equals : replaced return of integer sized value with (x == 0 ? 1 : 0) → NO_COVERAGE |
return false; |
| 1031 | } | |
| 1032 |
1
1. equals : negated conditional → KILLED |
if (!PaintUtilities.equal(this.paint, that.paint)) { |
| 1033 |
1
1. equals : replaced return of integer sized value with (x == 0 ? 1 : 0) → KILLED |
return false; |
| 1034 | } | |
| 1035 |
1
1. equals : negated conditional → KILLED |
if (this.domainGridlinesVisible != that.domainGridlinesVisible) { |
| 1036 |
1
1. equals : replaced return of integer sized value with (x == 0 ? 1 : 0) → KILLED |
return false; |
| 1037 | } | |
| 1038 |
1
1. equals : negated conditional → KILLED |
if (!PaintUtilities.equal(this.domainGridlinePaint, |
| 1039 | that.domainGridlinePaint)) { | |
| 1040 |
1
1. equals : replaced return of integer sized value with (x == 0 ? 1 : 0) → KILLED |
return false; |
| 1041 | } | |
| 1042 |
1
1. equals : negated conditional → KILLED |
if (!ObjectUtilities.equal(this.domainGridlineStroke, |
| 1043 | that.domainGridlineStroke)) { | |
| 1044 |
1
1. equals : replaced return of integer sized value with (x == 0 ? 1 : 0) → KILLED |
return false; |
| 1045 | } | |
| 1046 |
2
1. equals : negated conditional → KILLED 2. equals : negated conditional → KILLED |
if (!this.rangeGridlinesVisible == that.rangeGridlinesVisible) { |
| 1047 |
1
1. equals : replaced return of integer sized value with (x == 0 ? 1 : 0) → KILLED |
return false; |
| 1048 | } | |
| 1049 |
1
1. equals : negated conditional → KILLED |
if (!PaintUtilities.equal(this.rangeGridlinePaint, |
| 1050 | that.rangeGridlinePaint)) { | |
| 1051 |
1
1. equals : replaced return of integer sized value with (x == 0 ? 1 : 0) → KILLED |
return false; |
| 1052 | } | |
| 1053 |
1
1. equals : negated conditional → KILLED |
if (!ObjectUtilities.equal(this.rangeGridlineStroke, |
| 1054 | that.rangeGridlineStroke)) { | |
| 1055 |
1
1. equals : replaced return of integer sized value with (x == 0 ? 1 : 0) → KILLED |
return false; |
| 1056 | } | |
| 1057 |
1
1. equals : replaced return of integer sized value with (x == 0 ? 1 : 0) → KILLED |
return true; |
| 1058 | } | |
| 1059 | ||
| 1060 | /** | |
| 1061 | * Returns a clone of the plot. | |
| 1062 | * | |
| 1063 | * @return A clone. | |
| 1064 | * | |
| 1065 | * @throws CloneNotSupportedException if some component of the plot does | |
| 1066 | * not support cloning. | |
| 1067 | */ | |
| 1068 | public Object clone() throws CloneNotSupportedException { | |
| 1069 | ||
| 1070 | FastScatterPlot clone = (FastScatterPlot) super.clone(); | |
| 1071 |
1
1. clone : negated conditional → SURVIVED |
if (this.data != null) { |
| 1072 | clone.data = ArrayUtilities.clone(this.data); | |
| 1073 | } | |
| 1074 |
1
1. clone : negated conditional → SURVIVED |
if (this.domainAxis != null) { |
| 1075 | clone.domainAxis = (ValueAxis) this.domainAxis.clone(); | |
| 1076 |
1
1. clone : removed call to org/jfree/chart/axis/ValueAxis::setPlot → SURVIVED |
clone.domainAxis.setPlot(clone); |
| 1077 |
1
1. clone : removed call to org/jfree/chart/axis/ValueAxis::addChangeListener → SURVIVED |
clone.domainAxis.addChangeListener(clone); |
| 1078 | } | |
| 1079 |
1
1. clone : negated conditional → SURVIVED |
if (this.rangeAxis != null) { |
| 1080 | clone.rangeAxis = (ValueAxis) this.rangeAxis.clone(); | |
| 1081 |
1
1. clone : removed call to org/jfree/chart/axis/ValueAxis::setPlot → SURVIVED |
clone.rangeAxis.setPlot(clone); |
| 1082 |
1
1. clone : removed call to org/jfree/chart/axis/ValueAxis::addChangeListener → SURVIVED |
clone.rangeAxis.addChangeListener(clone); |
| 1083 | } | |
| 1084 |
1
1. clone : mutated return of Object value for org/jfree/chart/plot/FastScatterPlot::clone to ( if (x != null) null else throw new RuntimeException ) → KILLED |
return clone; |
| 1085 | ||
| 1086 | } | |
| 1087 | ||
| 1088 | /** | |
| 1089 | * Provides serialization support. | |
| 1090 | * | |
| 1091 | * @param stream the output stream. | |
| 1092 | * | |
| 1093 | * @throws IOException if there is an I/O error. | |
| 1094 | */ | |
| 1095 | private void writeObject(ObjectOutputStream stream) throws IOException { | |
| 1096 |
1
1. writeObject : removed call to java/io/ObjectOutputStream::defaultWriteObject → KILLED |
stream.defaultWriteObject(); |
| 1097 |
1
1. writeObject : removed call to org/jfree/chart/util/SerialUtilities::writePaint → KILLED |
SerialUtilities.writePaint(this.paint, stream); |
| 1098 |
1
1. writeObject : removed call to org/jfree/chart/util/SerialUtilities::writeStroke → KILLED |
SerialUtilities.writeStroke(this.domainGridlineStroke, stream); |
| 1099 |
1
1. writeObject : removed call to org/jfree/chart/util/SerialUtilities::writePaint → KILLED |
SerialUtilities.writePaint(this.domainGridlinePaint, stream); |
| 1100 |
1
1. writeObject : removed call to org/jfree/chart/util/SerialUtilities::writeStroke → KILLED |
SerialUtilities.writeStroke(this.rangeGridlineStroke, stream); |
| 1101 |
1
1. writeObject : removed call to org/jfree/chart/util/SerialUtilities::writePaint → KILLED |
SerialUtilities.writePaint(this.rangeGridlinePaint, stream); |
| 1102 | } | |
| 1103 | ||
| 1104 | /** | |
| 1105 | * Provides serialization support. | |
| 1106 | * | |
| 1107 | * @param stream the input stream. | |
| 1108 | * | |
| 1109 | * @throws IOException if there is an I/O error. | |
| 1110 | * @throws ClassNotFoundException if there is a classpath problem. | |
| 1111 | */ | |
| 1112 | private void readObject(ObjectInputStream stream) | |
| 1113 | throws IOException, ClassNotFoundException { | |
| 1114 |
1
1. readObject : removed call to java/io/ObjectInputStream::defaultReadObject → KILLED |
stream.defaultReadObject(); |
| 1115 | ||
| 1116 | this.paint = SerialUtilities.readPaint(stream); | |
| 1117 | this.domainGridlineStroke = SerialUtilities.readStroke(stream); | |
| 1118 | this.domainGridlinePaint = SerialUtilities.readPaint(stream); | |
| 1119 | ||
| 1120 | this.rangeGridlineStroke = SerialUtilities.readStroke(stream); | |
| 1121 | this.rangeGridlinePaint = SerialUtilities.readPaint(stream); | |
| 1122 | ||
| 1123 |
1
1. readObject : negated conditional → SURVIVED |
if (this.domainAxis != null) { |
| 1124 |
1
1. readObject : removed call to org/jfree/chart/axis/ValueAxis::addChangeListener → SURVIVED |
this.domainAxis.addChangeListener(this); |
| 1125 | } | |
| 1126 | ||
| 1127 |
1
1. readObject : negated conditional → SURVIVED |
if (this.rangeAxis != null) { |
| 1128 |
1
1. readObject : removed call to org/jfree/chart/axis/ValueAxis::addChangeListener → SURVIVED |
this.rangeAxis.addChangeListener(this); |
| 1129 | } | |
| 1130 | } | |
| 1131 | ||
| 1132 | } | |
Mutations | ||
| 197 |
1.1 |
|
| 200 |
1.1 |
|
| 208 |
1.1 |
|
| 209 |
1.1 |
|
| 211 |
1.1 |
|
| 212 |
1.1 |
|
| 232 |
1.1 |
|
| 243 |
1.1 |
|
| 256 |
1.1 |
|
| 265 |
1.1 |
|
| 276 |
1.1 |
|
| 290 |
1.1 |
|
| 294 |
1.1 |
|
| 305 |
1.1 |
|
| 319 |
1.1 |
|
| 323 |
1.1 |
|
| 335 |
1.1 |
|
| 347 |
1.1 |
|
| 351 |
1.1 |
|
| 364 |
1.1 |
|
| 377 |
1.1 |
|
| 379 |
1.1 |
|
| 392 |
1.1 |
|
| 404 |
1.1 |
|
| 408 |
1.1 |
|
| 420 |
1.1 |
|
| 432 |
1.1 |
|
| 436 |
1.1 |
|
| 448 |
1.1 |
|
| 461 |
1.1 |
|
| 463 |
1.1 |
|
| 476 |
1.1 |
|
| 488 |
1.1 |
|
| 492 |
1.1 |
|
| 504 |
1.1 |
|
| 516 |
1.1 |
|
| 520 |
1.1 |
|
| 540 |
1.1 |
|
| 541 |
1.1 |
|
| 546 |
1.1 |
|
| 555 |
1.1 |
|
| 556 |
1.1 |
|
| 560 |
1.1 |
|
| 566 |
1.1 |
|
| 567 |
1.1 |
|
| 572 |
1.1 |
|
| 573 |
1.1 |
|
| 576 |
1.1 |
|
| 578 |
1.1 |
|
| 579 |
1.1 |
|
| 580 |
1.1 |
|
| 601 |
1.1 |
|
| 616 |
1.1 |
|
| 617 |
1.1 2.2 3.3 |
|
| 627 |
1.1 |
|
| 647 |
1.1 |
|
| 649 |
1.1 |
|
| 655 |
1.1 |
|
| 656 |
1.1 |
|
| 657 |
1.1 |
|
| 673 |
1.1 |
|
| 675 |
1.1 |
|
| 681 |
1.1 |
|
| 682 |
1.1 |
|
| 683 |
1.1 |
|
| 700 |
1.1 |
|
| 703 |
1.1 |
|
| 706 |
1.1 |
|
| 720 |
1.1 |
|
| 723 |
1.1 2.2 3.3 |
|
| 725 |
1.1 2.2 |
|
| 728 |
1.1 2.2 |
|
| 732 |
1.1 2.2 |
|
| 737 |
1.1 |
|
| 752 |
1.1 |
|
| 755 |
1.1 2.2 3.3 |
|
| 757 |
1.1 2.2 |
|
| 760 |
1.1 2.2 |
|
| 764 |
1.1 2.2 |
|
| 768 |
1.1 |
|
| 781 |
1.1 |
|
| 799 |
1.1 |
|
| 805 |
1.1 |
|
| 808 |
1.1 |
|
| 825 |
1.1 |
|
| 837 |
1.1 |
|
| 855 |
1.1 |
|
| 861 |
1.1 |
|
| 864 |
1.1 |
|
| 881 |
1.1 |
|
| 890 |
1.1 |
|
| 899 |
1.1 |
|
| 911 |
1.1 |
|
| 935 |
1.1 |
|
| 961 |
1.1 2.2 |
|
| 965 |
1.1 2.2 |
|
| 966 |
1.1 |
|
| 967 |
1.1 |
|
| 969 |
1.1 2.2 3.3 |
|
| 984 |
1.1 2.2 |
|
| 988 |
1.1 |
|
| 989 |
1.1 |
|
| 990 |
1.1 |
|
| 992 |
1.1 2.2 3.3 |
|
| 1007 |
1.1 |
|
| 1008 |
1.1 |
|
| 1010 |
1.1 |
|
| 1011 |
1.1 |
|
| 1013 |
1.1 |
|
| 1014 |
1.1 |
|
| 1017 |
1.1 |
|
| 1018 |
1.1 |
|
| 1020 |
1.1 |
|
| 1021 |
1.1 |
|
| 1023 |
1.1 |
|
| 1024 |
1.1 |
|
| 1026 |
1.1 |
|
| 1027 |
1.1 |
|
| 1029 |
1.1 |
|
| 1030 |
1.1 |
|
| 1032 |
1.1 |
|
| 1033 |
1.1 |
|
| 1035 |
1.1 |
|
| 1036 |
1.1 |
|
| 1038 |
1.1 |
|
| 1040 |
1.1 |
|
| 1042 |
1.1 |
|
| 1044 |
1.1 |
|
| 1046 |
1.1 2.2 |
|
| 1047 |
1.1 |
|
| 1049 |
1.1 |
|
| 1051 |
1.1 |
|
| 1053 |
1.1 |
|
| 1055 |
1.1 |
|
| 1057 |
1.1 |
|
| 1071 |
1.1 |
|
| 1074 |
1.1 |
|
| 1076 |
1.1 |
|
| 1077 |
1.1 |
|
| 1079 |
1.1 |
|
| 1081 |
1.1 |
|
| 1082 |
1.1 |
|
| 1084 |
1.1 |
|
| 1096 |
1.1 |
|
| 1097 |
1.1 |
|
| 1098 |
1.1 |
|
| 1099 |
1.1 |
|
| 1100 |
1.1 |
|
| 1101 |
1.1 |
|
| 1114 |
1.1 |
|
| 1123 |
1.1 |
|
| 1124 |
1.1 |
|
| 1127 |
1.1 |
|
| 1128 |
1.1 |


|
| | Builder (TToggleField component) |
| |
| virtual TBuilder | SwitchState (bool? switchState) |
| | Thumbs value More...
|
| |
| virtual TBuilder | ActiveLabel (string activeLabel) |
| | The label to add to the toggle field when it is toggled on. Only available in the Blackberry theme. More...
|
| |
| virtual TBuilder | InactiveLabel (string inactiveLabel) |
| | The label to add to the toggle field when it is toggled of. Only available in the Blackberry theme. More...
|
| |
| virtual TBuilder | MaxValueCls (string maxValueCls) |
| | CSS class added to the field when toggled to its maxValue. More...
|
| |
| virtual TBuilder | MinValueCls (string minValueCls) |
| | CSS class added to the field when toggled to its minValue.   More...
|
| |
| virtual TBuilder | MaxValue (double maxValue) |
| | The highest value any thumb on this slider can be set to. Defaults to 100. More...
|
| |
| virtual TBuilder | MinValue (double minValue) |
| | The lowest value any thumb on this slider can be set to. Defaults to 0. More...
|
| |
| virtual TBuilder | ReadOnly (bool? readOnly) |
| | Will make this field read only, meaning it cannot be changed with used interaction. More...
|
| |
| virtual TBuilder | SetCls (string cls) |
| |
| virtual TBuilder | SetIncrement (double increment) |
| |
| virtual TBuilder | SetLiveUpdate (bool liveUpdate) |
| |
| virtual TBuilder | SetMaxValue (Double value) |
| |
| virtual TBuilder | SetMinValue (Double value) |
| |
| virtual TBuilder | SetValue (double value) |
| |


The City of Chicago is selling vacant lots on the South Side for $1 until April 21, 2014. Here's how you get one.
Please note: The Large Lots Pilot Program ended on April 21st, 2014 and the City of Chicago is no longer accepting applications.
Enter your address or browse on the map below to find the lot(s) you would like to purchase.
The city is only selling lots that are residential and have no buildings on them.
Each lot has its own 14-digit PIN number. Write it down for your application.
To get started:
To purchase a lot, you need to put together an application package to mail to the City of Chicago's Department of Planning and Development.
This package will include:
Download and fill out the Large Lot Pilot Program application form.
The City requires that you submit a copy of your deed to prove that you already own property on the block. If you don't have it handy, you can get it online or pick it up in person.
Download a copy from the Cook County Recorder of Deeds
You can download a copy from the Cook County Recorder of Deeds website for $2.50.
You will need to know the PIN of your own property. You can look it up by your address on CookCountyPropertyInfo.com.
Or pick it up in person
You can also go to the Cook County Recorder of Deeds office and get a printed copy.
Cook County Recorder of Deeds
118 N. Clark St, Room 120
Chicago, IL 60602
Everyone who does business with the City of Chicago needs to fill out an Economic Disclosure Statement (EDS), and since you are buying a lot from them, you need to fill one out too.
Many of the sections on the form are for businesses, so fill it out to the best of your ability according to the instructions.
Large Lot Pilot Program applications must be received by the close of business on April 21, 2014. Incomplete applications will not be considered.
Mail your complete application package to:
Department of Planning and Development
Attn: Jeanne Chandler
121 N. LaSalle Street, Room 905
Chicago, IL 60602
The amount of yearly property tax you will pay is determined by the Cook County Assessor and based on the assessed value of the property and the tax rates for all local governments providing services in your community.
To get a sense of what the property tax will be for your vacant lot, we took a look at the taxes paid for a few vacant lots sold by the City of Chicago:
| Address | Sq ft | Assessed value | 2012 taxes | Sold on |
| 5302 S Winchester Ave | 2,892 | $15,900 | $287.65 | Sept 8, 2011 |
| 745 N Cicero Ave | 3,305 | $28,268 | $548.01 | Jul 6, 2011 |
| 1319 S Tripp Ave | 3,142 | $31,420 | $563.81 | Apr 13, 2011 |
| 1326 W 109th St | 3,730 | $20,510 | $368.83 | March 9, 2011 |
No you will not. When the lot is sold, no unpaid taxes by the previous owner will be transferred to you.
Read more about this program on the City of Chicago website. Please direct questions about the Large Lot Pilot Program to:
Jeanne Chandler
Department of Planning and Development
Phone:<PHONE_NUMBER>
Email<EMAIL_ADDRESS>If you have questions about the LargeLots.org website, contact Demond Drummer at<EMAIL_ADDRESS>LargeLots.org was initiated by Demond Drummer at Teamwork Englewood, built by DataMade and funded by LISC Chicago with support from the Boeing Corporation, and the Knight Foundation for LISC's OpenGov for the Rest of Us project.
Our map was built using open data from Chicago and Cook County:
We prepared some extracts of the above sources for this project. You can download those here:
All the code for this site is open source and available on Github. We used the following open source tools:


About me
I am a person that likes to mess around with loads of programs and hobbys, I've used cinima 4D, photoshop, lightroom, illustator, blender, and premire pro. So quite a lot of programs. I've also taken classes in, graphic design, digital photography, film photography (as well as having a dark room in my house), and cinematography. I am quite young at 19 years old, I graduated High school in 2016, after high school I got a job working at Lowes Home emprovment for a year unil I decided to come back to school to learn more about coding hopfully to be come a devoloper. So far I have used languages such as css, javascript, sass, and jquery.


Grocery-carrying robots are coming, do we need them?
by EndPlayBOSTON (AP) -
The first cargo-carrying robot marketed directly to consumers is on sale this holiday season.
Corporate giants like Amazon, FedEx and Ford and some food-on-demand startups have already been experimenting with sending delivery robots to doorsteps.
Now the Italian company that makes the Vespa scooter is offering a stylish alternative to those blandly utilitarian machines.
It's named the Gita after the Italian word for a short, pleasurable excursion. Its makers describe it as a "hands-free carrier" that can hold produce and other objects as it follows its owner down a sidewalk.
Given its $3,250 price tag, however, tech industry analysts are already declaring the Gita as doomed to fail. They say the Gita needs a more practical application, such as lugging tools around warehouses, hospitals or factory floors.


IStudentInfo.IYear
Describes school year. Contains year id and register id which are needed in order to use the the API.
Fields
name: string - school year display name, for ex. 2017/2018
id: number - year id
registerId: number - register id


time to brush your teeth!
will you keep the faucet on or turn it off as you maintain your pearly whites?
faucet on
faucet off