A wrapper for The Cancer Imaging Archive's REST API. The Cancer Imaging Archive (TCIA) hosts de-identified medical images of cancer available for public download, as well as rich metadata for each image series. TCIA provides a REST API for programmatic access to the data. This package provides simple functions to access each API endpoint. For more information, see <https://github.com/pamelarussell/TCIApathfinder> and TCIA's website.
| Version: | 1.0.2 |
| Depends: | R (≥ 3.4.0) |
| Imports: | httr, jsonlite |
| Suggests: | knitr, rmarkdown, oro.dicom, testthat |
| Published: | 2018-01-24 |
| Author: | Pamela Russell [aut, cre] |
| Maintainer: | Pamela Russell <pamela.russell at ucdenver.edu> |
| License: | MIT + file LICENSE |
| NeedsCompilation: | no |
| CRAN checks: | TCIApathfinder results |
| Reference manual: | TCIApathfinder.pdf |
| Vignettes: |
Introduction to TCIApathfinder TCIApathfinder and downstream analysis |
| Package source: | TCIApathfinder_1.0.2.tar.gz |
| Windows binaries: | r-devel: TCIApathfinder_1.0.2.zip, r-release: TCIApathfinder_1.0.2.zip, r-oldrel: TCIApathfinder_1.0.2.zip |
| OS X binaries: | r-release: TCIApathfinder_1.0.2.tgz, r-oldrel: TCIApathfinder_1.0.2.tgz |
| Old sources: | TCIApathfinder archive |
Please use the canonical form https://CRAN.R-project.org/package=TCIApathfinder to link to this page.


{% extends "base.html" %} {% block htmlclass%}{{super}} home{% endblock %} {% block title %}TravelDash - Your own Public Transport Dashboard{% endblock %} {% block header %} {% endblock %} {% block content %}
Just want to know when your next buses/trains home are? Me too! Your dashboard shows just the stops and times that matter to you.
Leave it open in a browser tab, load it on your phone, or embed a dashboard in your team wiki. Have different dashboards for getting to work, home, or school? No problems.
Currently just Auckland and Wellington, New Zealand. Suggestions welcome for other cities.


Karvy barred from taking new clients
by Special CorrespondentThe Securities and Exchange Board of India (SEBI) has barred Karvy Stock Broking (KSBL) from taking new clients over alleged misuse of client funds. Further, the NSE has appointed a forensic auditor to examine in detail the alleged cases of misuse of client funds by the broking entity.
“The Depositories and Stock Exchanges shall initiate appropriate disciplinary regulatory proceedings against [KSBL] for misuse of clients’ funds and securities,” SEBI added.
The SEBI order said the broking firm credited funds generated by pledging client securities in its own account. Further, an amount of ₹1,096 crore was transferred from the firm to its group entity Karvy Realty between April 2016 and October 2019.


Uniaro University was established by J.H Merthon in 1920 for the public benefit. After wards, it is recognized globally. Throughout our great history, Merthon has offered access to a wide range of academic opportunities. Like an international reputation for excellence across the sciences. The University has pioneered change in the sector. We are one of the largest with over 80,000 students. Learn from the experts and faculty who are always engaged in teaching to push the boundaries.
Don’t hesitate, contact us for better help and services. Explore all Services.
Don’t hesitate, contact us for better help and services. View More Events.
If you dream about getting educated from one of the top universities then definitely check these series of programs. Learn from the experts and faculty who are always engaged in teaching and research to push the boundaries.
If you dream about getting educated from one of the top universities then definitely check these series of programs. Learn from the experts and faculty who are always engaged in teaching and research to push the boundaries.
If you dream about getting educated from one of the top universities then definitely check these series of programs. Learn from the experts and faculty who are always engaged in teaching and research to push the boundaries.
If you dream about getting educated from one of the top universities then definitely check these series of programs. Learn from the experts and faculty who are always engaged in teaching and research to push the boundaries.
Don’t hesitate, contact us for better help and services. View more Instructor.


How to Read Code(En Version)
I wrote a document in 2019 [“How to read a source code?”] (https://www.codedump.info/post/20190324-how-to-read-code/), and now looking back, there is room for improvement in this document,so I have reorganized it on top of that.
The ability to read source code is considered to be one of the underlying fundamental programmer skills, and the reason why this ability is important is that
- inevitably need to read or take over other people’s projects. For example, researching an open source project, such as taking over a project from someone else.
- Reading good project source code is one of the important ways to learn from other people’s good experience, which I know myself.
Reading code and writing code are two not quite the same skills, the reason is that “writing code is expressing yourself, reading code is understanding others”. Because of the many projects, the authors of the project have their own style, it takes a lot of energy to understand.
I’ve been in the business for years reading the project source code in general and in detail, and have written some code analysis articles one after another, so I’ll briefly summarize my approach in this article.
the first thing:run it!
The first step to start reading a project source code, is to let the project through your own compilation and run smoothly. This is especially important.
Some projects are complex and depend on many components, so it is not easy to set up a debugging environment, so it is not always possible for all projects to run smoothly. If you can compile and run it yourself, then the scenario analysis, plus debugging code, debugging, and so on will have the basis to unfold.
In my experience, a project code, whether the debugging environment can be built smoothly, the efficiency is very different.
After running, and to try to streamline their environment to reduce the debugging process of interference information. For example, Nginx uses multiple processes to process requests. In order to debug the behavior of Nginx, I often set the number of workers to 1, so that when debugging you know which process is to be tracked.
For example, many projects are compiled with optimization options or without debugging information by default, which can be a problem when debugging, so I modify the makefile to compile to -O0 -g
, which is compiled to generate a version with debugging information and no optimization.
All in all, the debugging efficiency can be improved a lot after running, but under the premise of running and trying to streamline the environment to exclude the disturbing factors.
Clearly define your purpose
Although it is important to read the project source code, not all projects need to be read from start to finish. Before you start reading, you need to be clear about your purpose: whether you need to understand the implementation of one of the modules, the general structure of the framework, the implementation of one of the algorithms, and so on.
For example, many people look at the code of Nginx, and the project has many modules, including the basic core modules (epoll, network sending and receiving, memory pooling, etc.) and modules that extend a specific function, and not all of these modules need to be understood very clearly.
- Understanding the underlying processes at the core of Nginx and the data structures.
- Understanding how Nginx implements a module.
With this general understanding of the project, all that remains is to look at the specific code implementation when you encounter a specific problem.
All in all, it is not recommended to start reading the code of a project without a purpose, as looking at it headlessly will only consume your time and enthusiasm.
Distinguish between main and branch storylines
With a clear purpose in mind, you can distinguish between main and subplots in the reading process. For example.
- For example, if you want to understand the implementation of a business logic that uses a dictionary to store data in a function, here, “how the dictionary data structure is implemented” is a side plot, and you don’t need to look deeper into its implementation.
Guided by this principle, the reader only needs to understand the external interfaces to the code of the stems, such as a class that does not need to understand its implementation, and to understand the entry and exit parameters and the role of these interfaces, treating this part as a “black box”.
By the way, in the early years, I saw a way of writing C++ in which the header file contains only the external interface declaration of a class, and the implementation is transferred to the C++ file through an internal impl class, for example.
Header file.
// test.h
class Test {
public:
void fun();
private:
class Impl;
Impl *impl_;
};
C++ file.
void Test::fun() {
impl_->fun()
}
class Test::Impl {
public:
void fun() {
// Concrete implementation
}
}
This way of writing makes the header file a lot cleaner: there are no private members or functions associated with the implementation, only the exposed interface, so the user can know at a glance what the class offers to the public.
! impl
The “main” and “branch” storylines switch frequently throughout the code reading process, requiring the reader to have some experience in knowing which part of the code they are reading is the main storyline.
Vertical and horizontal
The code reading process is divided into two different directions.
- Vertical: Read in the order of the code. Vertical reading is often required when a specific understanding of a process or algorithm is needed.
- Horizontal: Read different modules, and often when you need to first figure out the overall framework, you need to read horizontally.
The two directions of reading, should alternate, which requires the code reader to have some experience and be able to grasp the current direction of code reading. My advice is: the process still puts the whole first, and do not go too deep into a particular detail without understanding the overall premise. Consider a function or data structure as a black box, know their input and output, as long as it does not affect the understanding of the whole, then put it aside and move on.
Scenario analysis
If you have the previous foundation, you have been able to make the project run smoothly in your own debugging environment, and you have clarified the functions you want to understand, then you can do a scenario analysis of the project code.
The so-called “scenario analysis” is to construct some scenarios by yourself, and then analyze the behavior in these scenarios by adding breakpoints and debugging statements.
For example, when I wrote Lua Design and Implementation, I explained the process of interpreting and executing Lua virtual machine instructions, and needed to analyze each instruction, so I used scenario analysis. I would simulate the Lua script code that uses the instruction, and then breakpoint in the program to debug the behavior in these scenarios.
My usual approach is to add a breakpoint to an important entry function, then construct debugging code that triggers the scenario, and when the code stops at the breakpoint, observe the behavior of the code by looking at the stack, variable values, and so on.
For example, in Lua interpreter code, generating Opcode will eventually call the function luaK_code, so I’ll add a breakpoint above this function and construct the scene I want to debug, and as soon as I break at the breakpoint, I’ll see the complete call flow through the function stack: ``C
(lldb) bt
* thread #1: tid = 0xb1dd2, 0x00000001000071b0 lua`luaK_code, queue = 'com.apple.main-thread', stop reason = breakpoint 1.1
* frame #0: 0x00000001000071b0 lua`luaK_code
frame #1: 0x000000010000753e lua`discharge2reg + 238
frame #2: 0x000000010000588f lua`exp2reg + 31
frame #3: 0x000000010000f15b lua`statement + 3131
frame #4: 0x000000010000e0b6 lua`luaY_parser + 182
frame #5: 0x0000000100009de9 lua`f_parser + 89
frame #6: 0x0000000100008ba5 lua`luaD_rawrunprotected + 85
frame #7: 0x0000000100009bf4 lua`luaD_pcall + 68
frame #8: 0x0000000100009d65 lua`luaD_protectedparser + 69
frame #9: 0x00000001000047e1 lua`lua_load + 65
frame #10: 0x0000000100018071 lua`luaL_loadfile + 433
frame #11: 0x0000000100000eb9 lua`pmain + 1545
frame #12: 0x00000001000090cd lua`luaD_precall + 589
frame #13: 0x00000001000098c1 lua`luaD_call + 81
frame #14: 0x0000000100008ba5 lua`luaD_rawrunprotected + 85
frame #15: 0x0000000100009bf4 lua`luaD_pcall + 68
frame #16: 0x00000001000046fb lua`lua_cpcall + 43
frame #17: 0x00000001000007af lua`main + 63
frame #18: 0x00007fff6468708d libdyld.dylib`start + 1
The advantage of scenario analysis is that instead of looking for a needle in a haystack, you can narrow down the problem to a scope and understand it.
The concept of “scenario analysis” is not a term I came up with. For example, there are several books that analyze code, such as Linux Kernel Source Code Scenario Analysis, Windows Kernel Scenario Analysis, and Windows Kernel Scenario Analysis. Windows Kernel Scenario Analysis"](https://book.douban.com/subject/3715700/).
Make use of good test cases
Good projects come with a lot of use cases, examples of this type are: etcd, a few open source projects produced by google.
If the test cases are written very carefully, then it is worthwhile to study them. The reason is: test cases are often for a single scenario, alone to construct some data to verify the process of the program. So, like the previous “scenario analysis”, it’s a way to move you from a big project to a specific scenario.
Clarify the relationship between core data structures
Although it is said that “programming = algorithm + data structure”, my experience in practice is that data structure is more important.
Because the structure defines the architecture of a program, there is no concrete implementation until the structure is set. Like building a house, the data structure is the framework structure of the house, if a house is very large, and you do not know the structure of the house, will be lost in it. As for the algorithm, if it is a part of the details that you do not need to delve into for the time being, you can refer to the previous section “Distinguishing the main and branch storylines” to understand the entrance and exit parameters and their roles first.
Linus says: “Bad programmers care about code. Good programmers care about data structures and how they relate to each other.”
Therefore, when reading a piece of code, it is especially important to clarify the relationships between the core data structures. At this time, it is necessary to use some tools to draw the relationship between these structures. There are many such examples in my source code analysis class blogs, such as Notes on Reading Leveldb Code, Implementation of Etcd Storage, and so on.
It should be noted that there is no strict sequential relationship between the two steps of scenario analysis and clarifying the core data structure; it does not have to be something first and then something else, but rather interactively.
For example, if you have just taken over a project and need to understand the project briefly, you can first read the code to understand what core data structures are available. Once you understand it, if you are not sure about the process in certain scenarios, you can use scenario analysis. In short, alternate until your questions are answered.
Ask yourself more questions
The learning process cannot be separated from the interaction.
If reading code is just an input, then there needs to be an output. Only simple input is like feeding something to you, and only better digestion can become your own nutrition, and output is an important means to better digest knowledge.
In fact, this idea is very common, for example, students need to do practice assignments (Output) in class (Input), such as learning algorithms (Input) need to practice their own coding (Output), and so on. In short, output is a kind of timely feedback in the learning process, and the higher the quality, the more efficient the learning.
There are many means of output, and when reading the code, it is more recommended to be able to ask yourself more questions, such as.
- Why did you choose this data structure to describe this problem? How are other projects designed in similar scenarios? What data structures are there to do such a thing?
- If I were to design such a project, what would I do?
And so on and so forth. The more active and positive thinking you do, the better output you will have, and the quality of output is directly proportional to the quality of learning.
Write your own code reading notes
Since I started blogging, I have been writing code reading articles for various projects, and my screen name “codedump” also comes from the idea of trying to “dump the code internal implementation principle”.
As mentioned earlier, the quality of learning is directly proportional to the quality of output, which is my own deep experience. Because of this, I insist on writing my own analysis notes after reading the source code.
Here are a few things to keep in mind when writing these kinds of notes.
Although they are notes, imagine that you are explaining the principles to someone who is less familiar with the project, or imagine that you are looking back at the article months or even years later. In this case, try to organize the language as well as possible and explain it in a step-by-step manner.
Try to avoid posting large paragraphs of code. I think it’s a bit self-defeating to post large paragraphs of code in such articles: it just looks like you understand it, but you don’t. If you really want to explain a piece of code, you can use pseudo-code or reduced code. Remember: don’t kid yourself, really get it. If you really want to add your own comments to the code, one suggestion I have is to fork a copy of some version of the project and commit it to your own github, where you can always add your own comments and save the commit. For example, my own commented code for etcd 3.1.10: etcd-3.1.10-codedump, similarly other projects I read will fork a project on github with codedump suffix of the project.
Draw more diagrams, a picture is worth a thousand words, use graphics to show the relationship between the code flow, data structures. I just recently discovered that the ability to draw diagrams is also an important ability, and I’m learning how to use images to express my ideas from scratch.
Writing is an important foundational ability, and a friend of mine recently educated me to the effect that if you are strong in something, if you add good writing and good English, then it will greatly amplify your ability in that area. And similar to writing, English such as the underlying basic ability, not a handful, need to keep practicing for a long time to be able to. And writing a blog, for technical staff, is a good means to exercise writing.
PS: If many things, you then do when you can think of the future to face the output of the person is your own, such as their own written code to maintain the back of their own articles written for their own eyes, and so on, the world will be much better. For example, writing a technical blog about these things, because I am writing when I consider that the person who will look at this document may be myself, so when writing will try to be clear and easy to understand, trying to see myself after a period of time when I see their own document, I can immediately recall the details of the time, but also because of this, I rarely post large sections of code in the blog, as far as possible to supplement the legend.
Summary
The above is my brief summary of some of the means and methods of attention when reading source code, in general there are so many points, right?
- Only better output can better digest the knowledge, the so-called build debugging environment, scenario analysis, ask yourself more questions, write code reading notes, etc. are all around the output to start. In short, you can’t be like a dead fish and expect to fully understand its principles just by reading the code, you need to find ways to interact with it.
- Writing is one of the basic hard skills of a person, not only to exercise their ability to express themselves, but also to help organize their thoughts. One means of exercising writing skills for programmers is to write a blog, and the sooner you start exercising, the better.
Finally, as with any skill that can be acquired, the ability to read code requires long hours and lots of repetition, so next time start working on a project that interests you.


 We specialise in bespoke, professional and seamlessly-run expeditions around the world.
A successful expedition is made up of the hundreds of small wonderful experiences gained from start to finish. We therefore ensure that every aspect of your trip is expertly organised and well-managed.
We operate in 6 countries. We respect and value the local communities with whom we work and have nurtured and built strong relationships with them. As a result, we feel we have a deeper understanding of how to best deliver the trip of a lifetime to you.
From time to time Mountain Expeditions uses a number of carefully and personally selected associate Mountain Leaders (MLs), Mountaineering Instructors (MIA/MICs) and Mountain Guides (UIAGM) to deliver expeditions, instuction and guiding.All of these people are chosen on their individual merits based on the mix of their technical skills, qualifications and excellent interpersonal skills. These guides are both friends as well as colleagues and understand the Mountain Expeditions ethos and deliver to the highest standards.
(my full write up from 2017) ‘Cold, remote & desolate. If at first you don’t succeed…’ Extract from my 2016 attempt: It was 04:00am and I needed to stop. I was hurting so much.
Sidetracked Magazine is an online and printed journal featuring a limited collection of personal stories of adventure travel, journeys and expeditions.
(my full write up from 2017) ‘Cold, remote & desolate. If at first you don’t succeed…’ Extract from my 2016 attempt: It was 04:00am and I needed to stop.
On every expedition, the number of participants is kept to a level to enable the highest quality to be maintained. We do not want to be that company where you become a number or even a blur after the expedition has finished, so we have a strict cut off point to ensure that our groups never become too big.
We strongly believe that by doing this our Mountain Expeditions Leaders are able to provide a more personalised service and we find that group dynamics work much better than when travelling in high numbers. Therefore, your success rate and enjoyment increases immeasurably.
Mountain Expeditions employs a small number of highly experienced Expedition Leaders to lead our trips. Carefully chosen for their experience, qualifications, personality and their ability to apply themselves to challenging situations.


I am based in South East Queensland.
My style and own view of teaching asanas (yoga poses) can be described as
Try various ranges from my cool-as-a-cucumber yoga, cardio yoga, or powerhouse personal training.
Instruction in Spanish is also available!
See you on your mat.
On offer is a unique hatha class focusing on a water-flow approach to your health, fitness and wellness. My style integrates the physical, mental, emotional and spiritual aspect of wellness to create a satisfying session of complete mind and body fitness.
I have over 20 years experience as a practitioner and 10 years as an RYT-200 certified instructor with Santosha Yoga Institute.
My yoga journey started in 1999 whilst seeking relaxation and rest from the busyness of living in a fast paced world of study and work. I also have 17 years practice in traditional martial arts, from Aikido to Brazilian Jiu Jitsu to Muay Thai, and encourage my students to use their Ujjayi (victorious breathing).
I am passionate about breathing in and living in the present moment, using yoga to encourage peaceful meditation. My classes are full of joyful variations suitable for practitioners of any experience level, at any stage of life.
For the most junior yogis, I'm certified in children's yoga with It's Yoga Kids, and have a Working With Children Check. Other classes include teenagers, couples, friend groups, mama-baby, special needs, senior, yoga for cyclists and runners, and more.
Personal training is also available, with a focus on fitness, posture and flexibility.
As a practicing yogi, my primary training strength is looking at a holistic approach with a preventative and re-habilitation focus. I then progress to understanding the needs of each individual, whether it’s creating a training program for a busy person with life balance challenges, or a well-rounded, alignment-based, beastly strength training program.
Each client is carefully provided an initial assessment, which includes information on commitment, attitude, sleep, nutrition, training and rest. Following with a 6 or 12 week assessment, access to personal encouragement when you’re losing motivation and one-on-one fitness coaching.
Sessions offered are individual, small group, and large group training classes. All classes may be indoor, outdoor or bootcamp style.
Each package purchased includes one free private yoga class and optional NLP session.
There's more! I am certified in Reformer Pilates, and hypnotherapy.
I have experience instructing a variety of classes, including Pilates mat work, Swiss ball, mindful meditation, and hip-hop yoga.
If you need help to break those bad habits and fully realise healthy life changes, I can offer neuro-linguistic programming (NLP) and hypnotherapy services for the treatment of


 It is very easy to prepare and looks so inviting. The fruity baked apples provides a wonderful contrast to the soft melting soufflé. Try trickling a little maple syrup over the tops of the apples as you serve it.
For this recipe you will need a 25cm/10in round baking dish (7cm/3in deep).
For the baked apples, preheat the oven to 170C/150C Fan/Gas 3½. Grease a baking tray with a little butter.
Melt the butter. Brush the apples with the melted butter and roll in the caster sugar to coat all over. Place on the greased tray and bake in the oven for 25–30 minutes, until almost tender and still holding their shape. Set aside.
For the soufflé, preheat the oven to 190C/170C Fan/Gas 5.
Melt 10g/¼oz butter. Grease the baking dish with the melted butter, then sprinkle with 20g/¾oz sugar. Wipe the rim of the dish with a damp cloth, this will stop the soufflé sticking to the rim and enable it to rise evenly.
Pour the milk into a saucepan, add the vanilla and bring to the boil. Lower the heat and add 60g/2¼oz sugar, the semolina, sultanas and calvados (if using). Simmer for 3 minutes, or until thickened, whisking constantly to keep it smooth. Transfer to a large bowl, sprinkle with a little sugar to prevent a crust forming and let the mixture cool slightly, for 2-3 minutes.
In a clean bowl, whisk the egg whites with the lemon juice until soft peaks form and then slowly add the remaining 20g/¾oz caster sugar, whisking constantly. Continue to whisk until stiff peaks form when the whisk is removed.
Mix the egg yolks into the warm milk mixture, then briskly whisk in a third of the whisked egg whites. Carefully fold in the remaining egg whites using a spatula or large metal spoon. As you fold in the egg whites, delicately cut and lift the mixture to ensure there is minimum loss of volume and lightness.
Pour the mixture into the prepared baking dish and place the baked apples in it. Dab a knob of butter on top of each apple and sprinkle caster sugar evenly over the surface of the pudding. Bake for 25 minutes or until the soufflé is risen and golden-brown. Sprinkle with icing sugar and serve.
You need JavaScript to view this clip.
Whisking egg whites
Ciders: Merrydown Medium Cider, Orchard Pig Charmer Medium Sparkling Cider or Barn Owl Farm Pressed Medium Cider.


The value `-sum f_k log_2(f_k)` where `f_k` is the proportion of the observations with category k.
In the top slot, the categorical field to analyze.
In the left slot, an optional second categorical field. The entropy is computed in every category of this field.


"Saving Private Ryan" Directed by Steven Spielberg **** (four stars)
War is Hell
There is an eerie surrealism as we descend from the gloomy skies over Omaha beach. The redundant waves mercilessly beat upon the transport boats carrying the first wave of American soldiers, each silently staring at their inevitable destiny. Some begin to vomit, a combination of seasickness and fear that can only mean one thing, war. The date is June 6, 1944, otherwise known as D-Day, the single most important battle of the last great war. And as the US LCVP boats finally begin to drop their doors to let the soldiers pour out onto the beach, a cold shock comes over you.  You have been transported onto those boats, and all the horrors of war that you have only read about suddenly become reality. What ensues is the most ferocious and horrific sequences in all of film history. Bullets rip through the air with wanton lust, tearing apart the first three lines of troops attempting to make it to shore. The camera is jolted as if to suggest that there is nothing anyone can do to stop this madness. German 75mm machine cannons relentlessly bombard the shoreline as rounds tear through the backs of helmets and blow off limbs. This is not Hollywood's glamorization of death, this is death in its truest form. Bodies drop by the hundreds, completely limp upon impact from the bullets. Soldiers lie screaming on the sand with only their hands keeping their insides from falling out. Medics begin treating the wounded and before long, become the wounded. The shore is soaked red in blood, yet the Americans continue on. And for nearly half an hour this onslaught carries forth, until finally, the beach is taken.
For Spielberg, the point is simple: War is Hell. There's no glory on the battlefield. Heroes die. Good men die. What we read in our history books means nothing. They merely consist of statistics of death tolls and fancy plans laid out by four star Generals. Saving Private Ryan is war seen through the eyes of a soldier, and what better choice to do that than with a man whose demeanor alone elicits courage and honor. Tom Hanks plays platoon captain John Miller who, after courageously leading his troops through the hell of D-Day, is sent on a mission to find and bring home private James Francis Ryan (Matt Damon). The reason: Ryan, who was dropped behind enemy lines in France as part of the Airborne infantry attack, is the only surviving brother of four enlisted in the war (his mother will be receiving all three telegrams at once), and the chief of Staff of the US military is determined to "get him the hell out of there." So Miller assembles his best men to help him traverse the French countryside in search for the fourth Ryan. His platoon includes stubborn Brooklynite private Reiben (Edward Burns), the strong-willed Sgt. Horvath (Tom Sizemore), shell-shocked translator Corporal Upham (Jeremy Davies), wisecracking Jewish-American private Mellish (Adam Goldberg), Medic Wade (Giovanni Ribisi) and sharp-shooting private Caparzo (Vin Diesel).
As the men march on, we begin to see the true destruction of war-torn France. Towns are filled with the rubble of smashed buildings, and scattered gunfire snaps through the deserted streets. Along the way we slowly get an intimate glimpse of each of the characters, and we become closer and closer to the platoon. When one of them dies, we feel as if we have lost a close friend. But despite the tragedies there's always a feeling that things are still OK because of Captain Miller's presence. Hanks' performance is brilliant. He is the quintessential every man's hero, exuding both fatherly poise and human vulnerability, and is the binding force behind Spielberg's film. When the epic final battle concludes, Hanks and Spielberg leave us with a hauntingly powerful admonition of the truth of war. There is no happy ending. We are left only with a simple reminder that in war, good men die so that good men may carry on the flame. In what is no doubt the greatest war film ever made, Spielberg has shown us that even in the darkest moments of humanity, there is still hope.
-Stephen Wong
Visit the Entertainment Insiders at: http://einsiders.home.mindspring.com
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


The C3 API focuses on a declaritve style API where most options and functionality callbacks
are specified in an options object. A visualization is created by instantiating one of the
visualization types from the C3 collection. When constructing with new
, pass in
a single argument that is the options object. The specific options supported vary based on
the type of visualization and are documented in the API Reference.
During creation, options in this options object become properties of your instantiated
visulization object for future reference or modification. Once you have created your object,
then just call render()
on it to actually render the chart.
That's all you need to do!
There are a few other standard methods available to update the chart if you want to make it
more dynamic such as resizing, updating the dataset, restyling it, etc.
For example:
var my_chart = new c3.Plot({ anchor: '#scatter_plot_example', height: 300, width: '50%', data: student_data, ... // Options to specify what the new chart should be }); my_chart.render(); // Render your new chart!
Attaching to the DOM
A visualization object needs to be attached to the DOM to actually be visible in your document.
There are a few of ways of doing this. The anchor
option can specify
an HTML DOM element which the visualization will attach to as a child when rendering.
Alternatively the anchor
option could specify a string which represents a CSS
selector that specifies the DOM node that should be attached to when rendering.
Example anchor
option values:
- '#my_node'
- document.querySelector('#my_node')
- $('my_node')[0]
- $('

').appendTo('#your_node')[0]
- d3.select('#my_node').node()
- d3.select('#your_node').append('div').attr('id','my_node').node()
If no anchor
option is specified, then C3 will create a new

element to contain the visualiztion. This element will not be attached to the DOM, but
will be accessible as the anchor
property of the visualization object for you
to attach to the DOM when and where you wish.
The visualization will be sized based on the size you specify via the height
and width
options. If you do not specify a size then it will use the size
of anchor element. If the anchor element is not attached to the DOM it may not have a size,
in this case you may need to resize the chart after attaching to the DOM.
Methods
The standard visualization API contains the following methods:
render([options])
-
The primary method used to actually render the visualization.
This should generally only be called once to initialize the visualization object. However, some visualizations with multiple layers may need to have
render()
called again if the set of layers changes.The
render
call optionally takes an additional options object that will be merged for additional options or potentially override options used when the object was created. resize([width, height])
-
Resize the visualization.
The visualization will be resized to match the current size of the anchor element. Optionally, a
width
andheight
can be specified to explicitly set a new size for the anchor element.For performance reasons, a
resize
operation will attempt to perform minimal work resizing and repositioning elements. Therefore, it may not reflect changes in the data set or other changed options. Use the other methods below for those types of changes.// Resize your chart when the window resizes window.onresize = function() { my_chart.resize(); }
redraw([origin])
-
A method to redraw the visualization to reflect a modified dataset or added/removed
dataset elements. It should also be used after modifying the some of the visualization object's
options after initial rendering, such as modified scales, modified accessors, etc.
Some visualizations support animations for modified/added/removed data. These animations generally need to be explicitly enabled in the C3 selection options.
An optional
origin
string may be used by some visualizations for optimizations. For performance reasons,redraw()
may not update the styles of existing elements. Userestyle()
for this.student_data.push({ name: "Bella", gender: "female", age: 27, grade: 3.4 }); my_chart.redraw();
restyle()
- Update the CSS styles and classes of all data elements to reflect what is specified in the C3 Selection Options. Use this either if you change the selection options or you change the data that might affect their dynamic styling based on the selection options.
Some visualizations may offer aditional methods.
For example, a selectable data table may offer a select()
method or
a zoomable chart may offer a zoom()
method.
These will be documented in the API Reference.
Data Sets
The data for a visualization is generally provided via a data
option.
It usually refers to an array of objects, but there isn't a restriction on the type
of objects. They could be simple numbers or complex nested structures.
Each visualization will have some set of appropriate options that allow you to specify
the shape of the data, or how to access that concept from the dataset.
For example, a scatter plot might have x
and y
options to
get the x and y positions of each data point and an r
option to get the radius
of the circle for each datapoint. These types of options can usually take constants as
values, such as saying all data point circles have a radius of 10. Or they can take
a callback function. The function you specify will be called for eash element in your
data
array and passed the data element as the first argument. Your callback
function should return the desired value for that data element.
Some visualization options also support calling the callback functions with additional
parameters. Often the second argument will be the index of the element in the
data
array. Though, some visualisations or combination of options do not
support this, such as enabling a filter
option.
So, a simple example scatter plot layer options might look like:
Because each visualization type may need slightly different configuration options, please refer to the API Reference documentation for details.... data: [ { name: "Joe", gender: "male", age: 16, grade: 3.2 }, { name: "Lisa", gender: "female", age: 18, grade: 2.3 }, { name: "Patrick", gender: "male", age: 28, grade: 1.2 }, { name: "Mandy", gender: "female", age: 32, grade: 3.8 }, { name: "Tommy", gender: "male", age: 9, grade: 1.7 }, ], x: function(d) { return d.age; }, y: function(d) { return d.grade; }, r: 10, filter: function(d) { return d.age >= 16; }, ...
Scales
Most visualizations contain a set of options for scales. XY plots have h
and v
for the horizontal and vertical scales. Polar charts have
r
and t
for the radial and angular scales.
C3 uses D3 scales for its scales.
A scale simply takes an input domain
value and provides an output range value. The extents of the domain and
range values are used to perform the conversion. So, if the x values of a scatter
plot might vary between 0 and 10 the domain of the horizontal scale may be
[0,10]
, this represents the x-axis. The range of the horizontal
dimension would be based on the current pixel width of the chart. C3 takes care of
properly setting the ranges of the scales, so you only have to worry about setting the domain.
The domains default to [0,1]
.
The most common scale type is linear
.
A linear scale performs a simple extrapolation from the input domain to the output range.
If the horizontal domain is [0,10]
and the chart width is 100 pixels,
then an x value of 2 will translate to 20 pixels, and so on.
But, D3 also provides other scale types such as
log
,
pow
,
and even ordinal
.
An example scatter plot may have the following scale options:
... h: d3.scale.linear().domain([0,50]), v: d3.scale.linear().domain([0,4]), ...
Layers
XY Plots and Polar charts support composition of multiple layers. A plot might contain an area graph layer with a bar chart layer on top with a line layer on top of that.
Layers are specified as an array of layer objects. The order of the layers in the array
represents the z ordering of the layers.
Layers objects are created much like visualization objects. The desired layer type should
be instantiated with new
and the constructor should be passed an options object.
Layers can inherit some options from their parent chart such as the scales and some
dataset accessor options; or, they can override them.
Our scatter plot example might have two layers:
... layers: [ new c3.Plot.Layer.Scatter({ ... }), new c3.Plot.Layer.Line.Horizontal({ data: [2.67], value: function(d) { return d; }, }), ], ...
Similar to layers, plots also support configuring axes via the axes
option which should be an array of c3.Axis
objects.
Selection Options
C3 creates and configures visual elements using C3 Selections, which are an abstraction of D3 Selections. The C3 Selections are user configurable using C3 Selection Options.
Visualization will expose options for the various visual elements that are part of that particular
visualization. For example, a table has options for table_options
for the
overall

element, header_options
for the header

elements, row_options
for the

elements,
cell_options
for
, and so forth.
A plot chart has an options
option for the overall chart <svg>
element,
layer_options
for the SVG <g>
element for each layer, and so on.
A scatter plot layer also has an overall options
option as well as
point_options
for the SVG <g>
element for each data point,
circle_options
for the SVG <circle>
element in each data point,
label_options
for the SVG <text>
element in each data point,
and so on and so forth. Each different visualization may use a different set of visual elements
so please refer to the API Reference for details on a particular visualization.
The C3 Selection Options is an object that
contains can contain a set of optional properties for you to configure.
Like the data set options, the selection options can generally be provided either as a
constant value or a callback function. The callback functions will be called for each
element in the selection. The first parameter it is called with is the data
assocated with that item in the selection. This varies based on the selection.
The layer_options
callbacks would call with the layer object, the
scatter plot circle_options
would call with the data element from the user
data set bound to that data point, while it isn't applicable to the overall options
.
Depending on the visualization, additional parameters might also be provided such as the
index of the data element into the dataset array, the associated column number for a
cell in the table, etc.
Some example selection options properties include:
text
-
The
innerText
content of the element. Useful for selections for SVG text labels, table cells, etc. html
-
Similar to the
text
option except that it specifies the rawinnerHTML
instead of just text. You can use this to create nested elements, such as styling with
tags. Please be careful with this option as you may need to escape characters to properly render in HTML as appropriate and may need to guard against untrusted string sources which could expose you to creating