From Light to Data: A Practical Pipeline for Quantitative Analysis of Impressionist Color

1. Introduction: Reading Impressionism Through Data

Claude Monet (Oscar-Claude Monet, born November 14, 1840, in Paris; died December 5, 1926, at age 86) was one of the founders of French Impressionism and is often called “the leader of the Impressionists.” In 1872 he painted Impression, Sunrise (Impression, soleil levant), depicting the morning mist over the port of Le Havre; two years later, the Impressionist painters held their first joint exhibition, and a critic borrowed the title of the painting to mock them as “Impressionists,” which gave the movement its name. From his acceptance by the Salon in the 1860s to painting at Giverny into old age while nearly blind, Monet spent his life asking a single question: how does the same subject present a different face under different moments, light, and weather?

This way of asking is itself experimental in character. For example:

• Painting outdoors: Around 1858, guided by the landscape painter Eugène Boudin, Monet began going outside to observe natural light directly. Moving the place of observation from the studio to nature meant the object of study shifted from fixed local color to light itself, which changes continuously with the hour, weather, and season.
• Immediacy: The word “impression” first emphasizes a fleeting, transient visual sensation, so the works naturally carry contextual information such as time, light, and weather.
• Serialization: After settling at Giverny, Monet worked on the Water Lilies series for roughly 27 years; the Haystacks and Rouen Cathedral series likewise group the same motif under different lighting conditions. Variables are effectively controlled—only light, time of day, and season change—which methodologically comes very close to a “controlled experiment.”

From an art-historical standpoint, Impressionism broke through the conservative framework of 19th-century academic art, challenged the official art establishment, and opened a new direction for modern Western painting; later movements such as Fauvism and Cubism all drew nourishment from its exploration of light and shadow. From an engineering standpoint, this creative logic of “repeated observation → immediate recording → side-by-side comparison” is highly isomorphic to sampling, feature extraction, and controlled experiments in data analysis.

Building a reproducible, scalable color-analysis pipeline around Monet’s works therefore has at least three kinds of value:

1. Turning experiential descriptions like “sense of light” and “tonality” into measurable, comparable indicators;
2. Providing data support for color design, art-history research, exhibition curation, and teaching;
3. Serving as a general technical paradigm that can be ported to palette analysis in textiles, printing, and industrial design.

2. Analysis Framework and Data Model

2.1 Three levels of analysis

Before writing any code, it helps to clarify what to measure and why. This article divides the analysis into three levels:

• Single-work level: dominant palette, color composition, luminance distribution, and brushstroke texture. This answers “which colors make up this painting.”
• Series level: how color changes across time of day, season, and weather for the same motif, and how palette distributions drift between works of different periods. This answers “how the image changes as variables change.”
• Corpus level: the full set of works as a dataset, used for statistical regularities, style retrieval, and similarity analysis. This answers “what general patterns exist, and which works resemble each other.”

2.2 Metadata model

Reliable analysis starts with reliable metadata. Model the work information as a single “wide table,” where each record corresponds to one painting:

• Identity: internal work ID, image-file hash, version number;
• Subject and series: e.g., water lilies, haystacks, Rouen Cathedral, poppy fields, floral still lifes;
• Time and place: creation year (with month when necessary), creation location;
• Condition tags: time of day (dawn / morning / noon / dusk), season, weather;
• Technical attributes: canvas dimensions, image resolution, color mode, scanning device, and source-light color temperature;
• Art-historical notes: changes in eyesight, style periods, restoration records;
• Provenance: licensing terms, shareable scope, citation information.

The condition tags are the key to the whole framework. The works have “experimental” value precisely because they turn lighting and time of day into comparable variables. Prefer authoritative sources such as the work’s title and creation date for these tags; when information is genuinely missing, manual annotation can supplement it, but the annotation rules and confidence must be recorded.

2.3 Metric design

Every metric should be computable, interpretable, and reproducible:

• Computable: has an explicit algorithm and parameters;
• Interpretable: changes in the value map onto an artistic phenomenon;
• Reproducible: record random seeds, software versions, and input hashes so the same input always yields the same result.

Following these principles, this article selects the following metrics:

• Dominant palette and the area share of each color;
• Perceptual color distance (ΔE), used to compare works across periods and series;
• Local luminance contrast and highlight-area share, as proxy indicators for “luminance–sense of light”;
• Color-temperature proxy: the degree to which the image’s average hue shifts toward warm colors (red/orange/yellow) or cool colors (blue/cyan);
• Directional-energy distribution of brushstrokes, to quantify brushstroke orientation and brevity;
• Texture complexity, such as the contrast, entropy, and energy statistics of the gray-level co-occurrence matrix.

3. Step 1: Build a Normalized, Comparable Corpus

3.1 Organize by year, series, and subject

After moving to Vétheuil in 1878, Monet painted four floral still lifes, one of which is Flowers in a Pot. This is one of his rare floral still-life subjects, and it may show different color-composition characteristics from his landscape series, making it suitable as a control sample. When organizing the corpus, build the directory structure and partition keys on “year × series × subject.” This has two benefits:

• Analysis can scan only the target partition, reducing wasted reads;
• When data is added or revised, only the corresponding partition needs updating, simplifying version management.

3.2 Acquisition standards

The quality of the digital copies directly determines the credibility of the conclusions. Recommended practices:

• Version priority: Prefer open digital resources from public collecting institutions; when possible, standardize acquisition equipment and workflow within the same institution.
• Resolution: Long edge of at least 3000 pixels. Only at high resolution can fine brushstrokes be sampled effectively.
• Format: Save in a lossless format such as 16-bit TIFF or losslessly compressed PNG. Lossy compression produces artifacts at color-block edges that interfere with texture statistics.
• Framing completeness: Include the full canvas where possible, and crop away mounts, frames, and mats.
• Multispectral acquisition: Advanced labs can use multispectral imaging to measure surface reflectance rather than only recording device response. Such data is closer to the pigment’s actual color but is more expensive and best used as a calibration baseline.

3.3 Copyright and compliance

Monet died in 1926, and his works have entered the public domain. However, the photographic or scanning results of digital copies may be protected differently across countries and regions, so confirm the licensing terms and scope of use for each source before acquisition. Also retain complete provenance citations (collecting institution, image number, retrieval date) to keep the analysis traceable. On the market side, attention to Monet’s work stays high: in 2019, a Haystacks painting sold for USD 110.7 million, setting an Impressionist auction record; in 2024, a Water Lilies painting sold for USD 59 million. His works were exhibited in Shanghai and Hong Kong in 2014, and large audiences’ direct engagement has further increased demand for high-resolution digital resources.

4. Step 2: Image Preprocessing

4.1 Color management and device calibration

Different scanners, cameras, and displays respond to color differently. Without calibration, differences that look like “style differences” may actually be device differences. Engineering recommendations:

• Hardware calibration: Regularly calibrate devices against a standard color card, and record the calibration date and result;
• Shooting standard: Place a standard color card in the same frame as a color reference when shooting;
• Unified color space: Convert all images to the same working color space, such as sRGB or Adobe RGB, and embed the color profile;
• Acquisition standardization: Shoot under a stable, standard light source where possible, and record the source-light color temperature in the metadata.

4.2 Removing frames, background, and noise

• Background detection: Sample along the outer edge of the canvas to estimate the background color and its distribution, then remove pixels close to it;
• Local anomalies: Apply median filtering or manual review to isolated points that differ sharply from surrounding pixels (such as dust or scratches);
• Reflections and highlights: Specular reflection locally alters color values, so flag these separately and exclude them from statistics;
• Restoration marks: Known restoration areas should be excluded from style statistics.

4.3 Illumination correction

Shooting or scanning can introduce uneven illumination, such as darker corners or a brighter side of the frame. Such biases contaminate global luminance and color-temperature metrics. Common correction methods:

• Low-frequency illumination-field estimation: Apply a large-radius Gaussian blur to the image to obtain an illumination field, then “flatten” by dividing the original image by that field;
• Surface fitting: Fit a luminance surface with image position as the independent variable, then compensate per pixel;
• Color-card correction: Compute a correction matrix directly from a standard color card in the frame.

Correction strength must be moderate: over-flattening erases the work’s own light-and-shadow gradients—exactly the core information of Impressionism.

4.4 Scale normalization

To make cross-work comparison easier, rescale images to the same working resolution (for example, a 1600-pixel long edge). But the original high-resolution images must be preserved; brushstroke-level texture analysis must be done at the original resolution to avoid losing high-frequency detail through downsampling.

The following preprocessing code is illustrative and only shows the workflow:

def preprocess(image, dpi, card_patch=None, frame_mask=None, blur_radius=None):
    """
    Image preprocessing sketch:
    - Device calibration: prefer white balance and color correction based on a color card in the same frame
    - Illumination correction: apply low-frequency illumination-field flattening only for large-format camera captures
    - Structural removal: mask out non-canvas pixels by background color difference and framing mask
    """
    img = to_linear_rgb(image)            # convert to a linear color space
    if card_patch is not None:
        gains = gray_world_gains(card_patch)   # estimate channel gains from the gray/color card
        img = apply_gains(img, gains)
    if is_camera_capture(dpi) and blur_radius:
        illum = gaussian_blur(img, sigma=blur_radius)    # estimate the illumination field
        img = safe_divide(img, illum)                    # flatten to suppress uneven illumination
    canvas_mask = diff_from_background(img, tolerance=0.06)
    if frame_mask is not None:
        canvas_mask = canvas_mask & (~frame_mask)
    return img, canvas_mask

5. Step 3: Color Analysis and Palette Extraction

5.1 Choosing a color space

RGB is a device color space, and its numerical differences are not proportional to perceived differences. For example, a numerical gap of 10 is often far more visible in green regions than in blue regions. The CIE Lab color space, designed on the basis of human visual experiments, is approximately “perceptually uniform” across many gamuts: Euclidean distance approximates the color difference perceived by the eye fairly well. Clustering and distance computation should therefore be done in Lab space.

For computing color difference, the CIEDE2000 formula is recommended. It refines the weighting of lightness, chroma, and hue on top of Lab distance and matches subjective human judgment more closely. As a rule of thumb, a ΔE of about 2.3 is often treated as the “just noticeable” threshold and can serve as a reference scale when interpreting results.

5.2 Clustering algorithm and K-value selection

The essence of palette extraction is to compress hundreds of thousands or even millions of pixels into a few representative colors. The specific approach:

1. Weighted sampling: Use area-weighted k-means clustering. Monet’s late works have thick, heavily stacked brushstrokes; the physical thickness of the paint layer can be estimated with photometric-stereo-based 3D surface reconstruction. On color images, dark strokes tend to be accompanied by higher surface height, and local variance and height gradients can serve as auxiliary weights. With these signals, one can, to some degree, distinguish “the pigment’s own color” from “light-and-shadow brightness.”
2. Remove highlights: Regions that are near-pure-white with a large connected area are usually highlights or reflections and should be handled separately before clustering.
3. Determine the K value: Combine the silhouette coefficient with the elbow method, or directly set a target number of colors (such as 8) to ensure cross-work comparability. For series like Haystacks and Rouen Cathedral with continuous color-block transitions, scan a sequence of K values and evaluate comprehensively before deciding.

5.3 Avoiding common pitfalls

• Do not use the “most frequent color” to represent the dominant color. The mixed pixels at brushstroke edges are the most numerous and most easily become the mode, yet they are not the colors the painter actually used.
• Do not report colors while ignoring their share. The same set of colors in different proportions can look completely different.
• Do not mix reproduction images with original digital resources. Reproduction images have been color-graded and compressed, so their values are distorted; they are suitable only for demonstration, not for the formal dataset.

The illustrative code is as follows:

import numpy as np
def _weighted_kmeans(X, w, k, seed, n_init=5, max_iter=100):
    """Sketch of weighted k-means (can be replaced by an industrial-grade clustering library)"""
    rng = np.random.default_rng(seed)
    best_inertia, best_centers, best_labels = np.inf, None, None
    for _ in range(n_init):
        # Probability sampling by weight to improve initial-center quality (similar in spirit to k-means++)
        idx = rng.choice(len(X), size=k, replace=False, p=w / w.sum())
        centers = X[idx].copy()
        for _ in range(max_iter):
            d2 = ((X[:, None, :] - centers[None, :, :]) ** 2).sum(axis=2)
            labels = d2.argmin(axis=1)
            new_centers = centers.copy()
            for j in range(k):
                m = labels == j
                if m.any():
                    new_centers[j] = np.average(X[m], axis=0, weights=w[m])
            shift = np.abs(new_centers - centers).sum()
            centers = new_centers
            if shift < 1e-4:
                break
        inertia = float((w * d2[np.arange(len(X)), labels]).sum())
        if inertia < best_inertia:
            best_inertia, best_centers, best_labels = inertia, centers, labels
    return best_centers, best_labels, best_inertia
def extract_palette(lab_pixels, paint_weight, k=8, min_share=0.02, seed=42):
    """
    Extract an area-weighted palette in Lab space
    lab_pixels : pixel colors of the canvas region (Lab)
    paint_weight: paint weight (e.g., paint-layer thickness or local contrast)
    """
    w = paint_weight * (1.0 + 0.5 * local_contrast(lab_pixels))
    centers, labels, _ = _weighted_kmeans(lab_pixels, w, k=k, seed=seed)
    counts = np.bincount(labels, weights=paint_weight, minlength=k)
    order = np.argsort(-counts)                      # sort by area share, descending
    palette = []
    for j in order:
        share = counts[j] / counts.sum()
        if share >= min_share:
            palette.append({"lab": centers[j].tolist(),
                            "hex": lab_to_hex(centers[j]),
                            "share": round(float(share), 4)})
    return palette

5.4 Interpretation example: the Water Lilies series

The Water Lilies series is an ideal sample for observing color evolution: the motif is stable, the works span nearly three decades, the recording conditions vary markedly, and they can be cross-referenced with Monet’s changes in eyesight.

• Early water-lily works: The pond at dawn is veiled in thin mist, the tonality is soft, and the reflections of water and willows form subtle transitions between blue and green. Water, flowers, and sky—three light sources—reflect into one another in the same frame, a typical case of “multi-source color.”
• Late works: Especially after his cataracts worsened, bolder blues appear in the paintings, while yellows often shift toward red-leaning or green-leaning directions, and some works present an overall yellow-green tonality.

Computing the ΔE of the early and late water-lily palettes pairwise in Lab space can quantitatively answer questions such as:

• Does the dominant blue shift significantly toward higher chroma;
• Does the hue angle of the dominant yellow shift;
• Does the overall luminance distribution tend to darken.

It is important to stress that these results reflect a “record left by the act of painting” and are not equivalent to Monet’s actual visual experience at the time. Cataracts reduce the blue light reaching the eye and weaken the perception of blue; after cataract surgery in 1923, Monet also complained that “everything I see is blue,” a typical sign of increased short-wavelength transmission after lens removal. His late color shifts were therefore most likely the joint result of perceptual change and creative strategy. The data can tell us what changed; as for why it changed, that still requires art-historical and medical evidence for a comprehensive judgment.

6. Step 4: Light-and-Shadow and Brushstroke Feature Extraction

6.1 Illumination and time-of-day proxies

The “temporality” of Impressionist works can be roughly characterized by the following indicators:

• Luminance contrast: measure the brightness range between the 5th and 95th percentiles to gauge light-dark contrast;
• Highlight-area share: a larger highlight area often means stronger light or reflection;
• Color-temperature proxy: measure how much the hue distribution shifts toward the warm end;
• Warm-cool contrast: compute the area ratio of warm pixels to cool pixels.

Take Impression, Sunrise: the orange-red sun and its reflection act as a warm focal point against the blue-gray morning mist and water, forming a strong warm-cool contrast that these indicators should clearly reflect. Take the Rouen Cathedral series: paintings of different times and weather should show systematic differences in luminance contrast and the color-temperature proxy, which can verify the hypothesis that “variation within a series is significant while commonality across series is clear.”

For series works, take the time-of-day label as the independent variable and the color metrics as dependent variables, use ANOVA or the Kruskal-Wallis test to judge whether the between-group differences are significant, and use bootstrap to estimate confidence intervals. At the same time, always check the effect size: statistical significance does not equal artistic importance.

6.2 Brushstroke direction

Brushstroke direction can be characterized as follows:

• Gabor filter bank: filter the image with multiple orientations and scales and measure the energy share of each direction;
• Structure tensor: estimate the local gradient’s principal direction, then compute directional consistency;
• Gray-level co-occurrence matrix: compute texture features such as contrast, entropy, and energy.

Interpretation must be tied to the specific work:

• The water Monet paints is often rendered with horizontal, short strokes to depict shimmering light;
• The brushstrokes of water-lily leaves and flowers are more dispersed in direction;
• Scenes depicting wind show more obvious directional consistency.

6.3 Series comparison: Haystacks and Rouen Cathedral

The two series happen to represent two ways of controlling variables:

• The Haystacks series (c. 1890–1891): stacks of hay at the same location recur at different times, seasons, and weather, with the composition nearly constant and lighting conditions as the main variable.
• The Rouen Cathedral series (c. 1892–1894): from a studio across from the cathedral, the painter kept switching canvases as the light moved, depicting the same façade’s flow of color and atmosphere over the course of a day.

Group each set of works by “time of day” and compute the within-group and between-group color distances: if the within-series distance is clearly smaller than the distance between series, this shows that lighting conditions influence the image’s color more than the subject itself. This result can be quantitatively tested with one-way ANOVA or a linear mixed model, turning “the same building presents different faces under different light” into a verifiable statistical conclusion.

def angle_energy_histogram(gray, thetas=(0, 30, 60, 90, 120, 150)):
    """Sketch of a Gabor directional-energy histogram"""
    energy = []
    for th in thetas:
        resp = gabor_filter_bank(gray, theta=th, wavelengths=(4, 8, 16), bandwidth=1.0)
        energy.append(float(np.mean(resp ** 2)))
    e = np.array(energy, dtype=float)
    e = e / (e.sum() + 1e-12)                    # normalize for cross-work comparison
    return dict(zip(thetas, np.round(e, 4).tolist()))
def describe_lightness(gray):
    """Lightness and light-feel proxy metrics"""
    lo, hi = np.percentile(gray, [5, 95])
    bright = float((gray > 0.9).mean())
    return {"p5": round(float(lo), 4),
            "p95": round(float(hi), 4),
            "contrast_range": round(float(hi - lo), 4),
            "highlight_ratio": round(bright, 4)}

7. Step 5: Data Pipeline Design and Engineering Practice

When the sample size grows from a few dozen to hundreds or thousands of works, manual analysis is no longer sustainable, and an engineered data pipeline is needed.

7.1 Layered architecture

• Ingestion layer: Images are hosted in object storage. Raw files, derived images, and analysis results are stored in separate buckets and partitioned by “year / series / work ID,” with content addressing (naming by file hash) to deduplicate.
• Messaging and scheduling layer: Driven by a message queue and a task scheduler. Each painting corresponds to one message, decoupling tasks and smoothing peaks and troughs, which makes failure retries and dead-letter handling easier.
• Compute layer: Stateless analysis tasks run as containers on a container platform and autoscale by queue length. When training style-transfer or brushstroke-classification models is needed, use compute instances with GPUs.
• Storage and analytics layer: Metadata and per-pixel centroid results are stored in a columnar format for easy partition-pruned scans; summary metric results are written to an analytics database for querying and visualization.
• Observability layer: A logging service aggregates task logs, and monitoring and alerting track task success rate, latency, and queue backlog, notifying on-call staff promptly on anomalies.

Taking Baidu AI Cloud as an example, each of these layers can be implemented with its general product categories such as object storage, messaging service, container engine, logging service, and monitoring service; refer to the official documentation of each product for specific selection. Other cloud platforms have similar general product categories.

7.2 Pipeline configuration example

pipeline:
  name: impression-palette-analysis
  source:
    bucket: paintings-raw
    partition_keys: [year, series, work_id]
  steps:
    - preprocess: {white_balance: gray_card, illum_flatten: auto, keep_mask: true}
    - palette:    {color_space: Lab, k_search: [6, 8, 10, 12], selector: silhouette}
    - texture:    {gabor_thetas: [0, 30, 60, 90, 120, 150], glcm_distances: [1, 2, 4]}
    - light:      {percentiles: [5, 95], highlight_threshold: 0.9}
  sink:
    metadata: {type: columnar, partition_by: [year, series]}
    metrics:  {type: analytics_db, table: artwork_metrics}
  quality:
    max_ingest_fail_rate: 0.01        # alert if ingestion failure rate exceeds 1%
    max_backlog_seconds: 1800         # alert if queue backlog exceeds 30 minutes
    seed: 42

7.3 Runtime skeleton sketch

def handle_message(msg):
    work = load_metadata(msg["work_id"])
    obj = fetch_from_object_store(work["image_uri"])
    # Optional cache: read from origin when no cache entry exists
    cached = cache_get(f"metrics:{work['image_hash']}:{METRIC_VERSION}")
    if cached:
        metrics = cached
    else:
        img, mask = preprocess(obj.image, obj.dpi, obj.color_card, obj.frame_mask)
        lab = rgb_to_lab(img)[mask]
        palette = extract_palette(lab, paint_weight=estimate_paint_weight(img, mask), k=8)
        gray = rgb_to_gray(img)[mask]
        metrics = {
            "work_id": work["work_id"],
            "metric_version": METRIC_VERSION,        # bump on metric-definition changes to trigger a full recompute
            "palette": palette,
            "lightness": describe_lightness(gray),
            "stroke": angle_energy_histogram(gray),
            "ingest_version": work["ingest_version"],
        }
        cache_set(f"metrics:{work['image_hash']}:{METRIC_VERSION}", metrics, ttl=86400)
    write_columnar(metrics)                          # write to result storage
    write_analytics_db(metrics["work_id"], summarize(metrics))

7.4 Engineering details

• Idempotency: Use the image hash as the idempotency key so repeated consumption produces no duplicate results.
• Task isolation: Preprocessing, clustering, and texture analysis can scale independently. Texture analysis is compute-heavy and should be grouped separately with a reasonable concurrency limit.
• Batch management: Submit clustering tasks by batch, splitting large jobs into small ones to avoid overly long single runs.
• Failure retry: Distinguish retryable errors (such as network timeouts) from non-retryable ones (such as corrupt files). The latter go to a dead-letter queue for manual investigation.
• Version management: Preprocessing parameters, clustering parameters, and the algorithm version together determine the metric definition. When the definition changes, you must bump the metric version number and recompute the full dataset.
• Cost control: Store original high-resolution images in a low-frequency or archival storage tier; keep frequently accessed thumbnails in the standard tier with a content delivery network (CDN) for acceleration. For long-horizon retrospective analysis, spot/preemptible instances can lower costs, but checkpointing must be in place so jobs can resume after interruption.
• Parallel acceleration: Palette extraction is a “per-image independent, large-sample” task well suited to distributed parallelism. Computing palettes for the full set of works in parallel, then applying hierarchical clustering to the results, yields a “corpus-level palette.”

8. Application Scenarios and Result Interpretation

8.1 Typical applications

• Color design: Extract color schemes from classic works to inspire brand visuals, home textiles, film and TV art direction, and more;
• Education and exhibition: Provide exhibitions with quantifiable color interpretation, such as “how the color temperature of one motif changes at different times”;
• Retrieval and deduplication: Use a color histogram plus texture features as an image fingerprint to retrieve similar works or discover duplicate entries in a digital library;
• Style transfer: Use a work’s palette and brushstroke statistics as constraint parameters to generate digital images with an Impressionist style.

8.2 Three data-quality lessons drawn from Monet’s experience

1. Record acquisition conditions. Monet’s works from different periods correspond to different places, light, and creative conditions; data lacking condition information is hard to interpret. When acquiring metadata, record device, light source, and shooting parameters at the same time.
2. Beware of “observer bias.” After Monet’s cataracts worsened, the world he saw was already different from his early years, and the color that others perceive in the paintings is likewise affected by their own visual conditions. Every color measurement carries observer bias, so device calibration, a unified light source, and multi-person cross-validation should be built into the workflow.
3. Pay attention to the time dimension. The value of serial creation lies in comparison, and a data platform should likewise preserve version and history records. Works get updated through restoration and reshooting, so results must be traceable to a specific input version.

8.3 Limitations and risks

• A digital copy is not the original. Shooting light, color rendering, glass reflection, and post-processing all alter color values, so quantitative results are suitable only for relative comparison, not as the pigment’s absolute color.
• Models are not the human eye. Both clustering results and color-difference formulas rest on a specific visual model and may diverge from the audience’s subjective experience.
• Selection bias: Extant works, digitized works, and shareable works are filtered layer by layer, so the final dataset cannot represent the painter’s entire output.
• Statistical traps: Works within one series are highly correlated; pooling them directly overestimates sample size, so a mixed-effects model or series-stratified analysis should be used.
• Scope of use: Analysis results are suitable for supporting research and creative design, but should not be the sole basis for authenticating a work, nor be reduced to a stereotyped label like “this style = a certain color.”

9. Conclusion

Monet spent his life capturing the fleeting changes of light. From learning to paint outdoors around 1858, to Impression, Sunrise in 1872 giving Impressionism its name; from the four floral still lifes at Vétheuil in 1878 to the roughly 27-year exploration of the Water Lilies series in his later years, his serial creation turned “the same subject under different light” into comparable research samples. This method of “observe → record → compare” is highly consistent with the sampling, feature extraction, and controlled experiments of data analysis.

The quantitative analysis path built here can be summarized as:

1. Establish a trustworthy corpus through standardized acquisition and strict preprocessing;
2. Extract the dominant palette with a perceptual color space and area-weighted clustering;
3. Characterize light-and-shadow features with luminance, brushstroke, and texture metrics;
4. Conduct comparative analysis along the dimensions of series and period;
5. Support a large-scale, reproducible pipeline with a layered cloud architecture.

This method applies equally to any data-analysis task centered on “visual expression.” From Monet’s lifelong observation of light to algorithms’ measurement of pixels, only the tools change; what stays constant is respect for detail. Technology can make “feeling” measurable, but understanding art still depends on observation and reflection beyond the data.