Visualizing Data. Exploring and Explaining Data with the Processing Environment

Spis treści książki

• Visualizing Data
• SPECIAL OFFER: Upgrade this ebook with OReilly
• Preface
  • The Audience for This Book
  • Background Information
  • Overview of the Book
  • Safari Books Online
  • Acknowledgments
  • Conventions Used in This Book
  • Using Code Examples
  • Wed Like to Hear from You
• 1. The Seven Stages of Visualizing Data
  • Why Data Display Requires Planning
    • Too Much Information
    • Data Collection
    • Thinking About Data
    • Data Never Stays the Same
    • What Is the Question?
    • A Combination of Many Disciplines
    • Process
  • An Example
    • What Is the Question?
      • Acquire
      • Parse
      • Filter
      • Mine
      • Represent
      • Refine
      • Interact
  • Iteration and Combination
  • Principles
    • Each Project Has Unique Requirements
    • Avoid the All-You-Can-Eat Buffet
    • Know Your Audience
  • Onward
• 2. Getting Started with Processing
  • Sketching with Processing
    • Hello World
    • Hello Mouse
  • Exporting and Distributing Your Work
    • Saving Your Work
  • Examples and Reference
    • More About the size( ) Method
    • Loading and Displaying Data
  • Functions
    • Libraries Add New Features
  • Sketching and Scripting
    • Don't Start by Trying to Build a Cathedral
  • Ready?
• 3. Mapping
  • Drawing a Map
    • Explanation of the Processing Code
  • Locations on a Map
  • Data on a Map
    • Two-Sided Data Ranges
    • Provide More Information with a Mouse Rollover (Interact)
    • Updating Values over Time (Acquire, Mine)
    • Smooth Interpolation of Values over Time (Refine)
  • Using Your Own Data
    • Taking Data from the User
  • Next Steps
• 4. Time Series
  • Milk, Tea, and Coffee (Acquire and Parse)
  • Cleaning the Table (Filter and Mine)
  • A Simple Plot (Represent and Refine)
  • Labeling the Current Data Set (Refine and Interact)
  • Drawing Axis Labels (Refine)
    • Year Labels
    • Labeling Volume on the Vertical Axis
    • Bringing It All Together and Titling Both Axes
  • Choosing a Proper Representation (Represent and Refine)
  • Using Rollovers to Highlight Points (Interact)
  • Ways to Connect Points (Refine)
    • Showing Data As an Area
    • Further Refinements and Erasing Elements
    • Discrete Values with a Bar Chart (Represent)
  • Text Labels As Tabbed Panes (Interact)
    • Adding the Necessary Variables
    • Drawing Tabs Instead of a Single Title
    • Handling Mouse Input
    • Better Tab Images (Refine)
  • Interpolation Between Data Sets (Interact)
  • End of the Series
• 5. Connections and Correlations
  • Changing Data Sources
  • Problem Statement
  • Preprocessing
    • Retrieving Win/Loss Data (Acquire)
      • Data source for baseball statistics
    • Unpacking the Win/Loss files (Mine and Filter)
      • Introducing regular expressions
    • Retrieving Team Logos (Acquire, Refine)
    • Retrieving Salary Data (Acquire, Parse, Filter)
  • Using the Preprocessed Data (Acquire, Parse, Filter, Mine)
    • Team Names and Codes
    • Team Salaries
    • Win-Loss Standings
    • Team Logos
    • Finishing the Setup
  • Displaying the Results (Represent)
  • Returning to the Question (Refine)
    • Highlighting the Lines
    • A Better Typeface for Numeric Data
    • A Word About Typography
  • Sophisticated Sorting: Using Salary As a Tiebreaker (Mine)
  • Moving to Multiple Days (Interact)
    • Drawing the Dates
    • Load Standings for the Entire Season
    • Switching Between Dates
    • Checking Our Progress
  • Smoothing Out the Interaction (Refine)
  • Deployment Considerations (Acquire, Parse, Filter)
• 6. Scatterplot Maps
  • Preprocessing
    • Data from the U.S. Census Bureau (Acquire)
    • Dealing with the Zip Code Database File (Parse and Filter)
    • Building the Preprocessor
      • What about a binary data file or a database?
  • Loading the Data (Acquire and Parse)
  • Drawing a Scatterplot of Zip Codes (Mine and Represent)
  • Highlighting Points While Typing (Refine and Interact)
  • Show the Currently Selected Point (Refine)
  • Progressively Dimming and Brightening Points (Refine)
  • Zooming In (Interact)
  • Changing How Points Are Drawn When Zooming (Refine)
  • Deployment Issues (Acquire and Refine)
  • Next Steps
• 7. Trees, Hierarchies, and Recursion
  • Using Recursion to Build a Directory Tree
    • Caveats When Dealing with Files (Filter)
    • Recursively Printing Tree Contents (Represent)
  • Using a Queue to Load Asynchronously (Interact)
    • Showing Progress (Represent)
  • An Introduction to Treemaps
    • A Simple Treemap Library
    • A Simple Treemap Example
  • Which Files Are Using the Most Space?
    • Reading the Directory Structure (Acquire, Parse, Filter, Mine, Represent)
  • Viewing Folder Contents (Interact)
  • Improving the Treemap Display (Refine)
    • Maintaining Context (Refine)
    • Making Colors More Useful (Mine, Refine)
  • Flying Through Files (Interact)
    • Updating FileItem for zoom
    • Updating FolderItem
    • Adding a Folder Selection Dialog (Interact)
  • Next Steps
• 8. Networks and Graphs
  • Simple Graph Demo
    • Porting from Java to Processing
    • Interacting with Nodes
  • A More Complicated Graph
    • Using Text As Input (Acquire)
    • Reading a Book (Parse)
    • Removing Stop Words (Filter)
    • Smarter Addition of Nodes and Edges (Mine)
    • Viewing the Book (Represent and Refine)
    • Saving an Image in a Vector Format
    • Checking Our Work
  • Approaching Network Problems
  • Advanced Graph Example
    • Getting Started with Java IDEs
      • Step-by-step instructions if you're new to Eclipse
    • Obtaining a Web Server Logfile (Acquire)
    • Reading Apache Logfiles (Parse)
    • A Look at the Other Source Files
    • Moving from Processing to Java
      • Helpful additions in Java 1.5 (J2SE 5.0) and later
    • Reading and Cleaning the Data (Acquire, Parse, Filter)
      • Filtering site addresses and aliases
      • Filtering for useful page information
    • Bringing It All Together (Mine and Represent)
      • Mining unused nodes: Maintaining performance and readability
    • Depicting Branches and Nodes (Represent and Refine)
    • Playing with Data (Interact)
    • Drawing Node Names (Represent and Refine)
    • Drawing Visitor Paths (Represent and Refine)
  • Mining Additional Information
• 9. Acquiring Data
  • Where to Find Data
    • Data Acquisition Ethics
  • Tools for Acquiring Data from the Internet
    • Wget and cURL
    • NcFTP and Links
  • Locating Files for Use with Processing
    • The Data Folder
    • Uniform Resource Locator (URL)
    • Absolute Path to a Local File
    • Specifying Output Locations
  • Loading Text Data
    • Files Too Large for loadStrings( )
    • Reading Files Progressively
    • Reading Files Asynchronously with a Thread
    • Parsing Large Files As They Are Acquired
  • Dealing with Files and Folders
    • Using the Java File Object to Locate Files
  • Listing Files in a Folder
    • • Listing files with a filter class
      • Sorting file lists
    • Handling Numbered File Sequences
  • Asynchronous Image Downloads
  • Using openStream( ) As a Bridge to Java
  • Dealing with Byte Arrays
  • Advanced Web Techniques
    • Handling Web Forms
    • Pretending to Be a Web Browser
  • Using a Database
    • Getting Started with MySQL
    • Using MySQL with Processing
    • Other Database Options
    • Performance Aspects of Databases in Interactive Applications
  • Dealing with a Large Number of Files
• 10. Parsing Data
  • Levels of Effort
  • Tools for Gathering Clues
  • Text Is Best
    • Tab-Separated Values (TSV)
    • Comma-Separated Values (CSV)
    • Text with Fixed Column Widths
  • Text Markup Languages
    • HyperText Markup Language (HTML)
      • Embedding Tidy into a sketch
      • Is a parser necessary?
      • Using Swing's built-in HTML parser
      • Parsing and manipulating tables from HTML files
      • Other HTML parser libraries
      • Writing a custom HTML parser
    • Extensible Markup Language (XML)
      • Cleaning up XML
      • Example: Using the Processing XML library to read geocoding data
      • Other methods for parsing XML
    • JavaScript Object Notation (JSON)
  • Regular Expressions (regexps)
  • Grammars and BNF Notation
  • Compressed Data
    • GZIP Streams (GZ)
      • PKZip files (ZIP)
      • Other compression formats
  • Vectors and Geometry
    • Scalable Vector Graphics (SVG)
    • OBJ and AutoCAD DXF
    • PostScript (PS) and Portable Document Format (PDF)
    • Shapefile and Well-Known Text
  • Binary Data Formats
    • Excel Spreadsheets (XLS)
    • dBASE/xBase (DBF)
    • Arbitrary Binary Formats
    • Bit Shifting
    • DataInputStream
  • Advanced Detective Work
    • Watching Network Traffic
• 11. Integrating Processing with Java
  • Programming Modes
    • Basic
    • Continuous
    • Java
  • Additional Source Files (Tabs)
    • Using .java Source Files
  • The Preprocessor
  • API Structure
    • Event Handling
    • The size( ) Method
    • The main( ) Method
    • The frame Object
  • Embedding PApplet into Java Applications
    • Two Models for Updating the Screen
    • Embedding in a Swing Application
  • Using Java Code in a Processing Sketch
    • Using the Code Folder to Add .jar Files to a Sketch
    • Packaging Code into Libraries
  • Using Libraries
  • Building with the Source for processing.core
• Bibliography
  • Acquire and Parse
• Index
• About the Author
• Colophon
• SPECIAL OFFER: Upgrade this ebook with OReilly
• Copyright

pokaż cały spis treści

ukryj recenzje