molde 0.1.19__tar.gz

molde-0.1.19/PKG-INFO

@@ -0,0 +1,46 @@
+Metadata-Version: 2.4
+Name: molde
+Version: 0.1.19
+Summary: 
+Author: André Fernandes
+Author-email: fpf.andre@gmail.com
+Requires-Python: >=3.10
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: moviepy (>=1.0.3,<2.0.0)
+Requires-Dist: numpy (>=2.0,<3.0)
+Requires-Dist: qtpy (>=2.4.2,<3.0.0)
+Requires-Dist: vtk (>=9.3.1,<10.0.0)
+Description-Content-Type: text/markdown
+
+<div align="center">
+  <img height="90" src="logos/mold_horizontal_logo_dark_300dpi.png" alt="Logo" align="center">
+</div>
+
+# MOLDE
+**MO**PT **L**ightweight **De**sign (MOLDE) is a library created to standardize and make easier the creation and maintainance of internal products of the Multidisciplinary Optimization Group (MOPT).
+
+Here are the colors, icons, fonts and common interface components, that may be usefull for multiple MOPT projects.
+
+This is heavily inspired by [Carbon Design System](https://carbondesignsystem.com/), [Atlassian Design System](https://atlassian.design/), [Fast Design System](https://www.fast.design/), [Material Design](https://m3.material.io/) and [Bold Design System](https://bold.bridge.ufsc.br/pt/).
+
+# Colors 
+The color palettes are available [here](https://andrefpf.github.io/molde/).
+
+# Icons 
+A lot of free to use icons, from Material Design, are available [here](https://fonts.google.com/icons).
+Other icons may be necessary, and they will be made to match the same style.
+For consistency avoid using icons from other places.
+
+# Typeface
+The font choose for this system is [IBM Plex](https://www.ibm.com/plex/).
+The `.ttf` files for every version of the font, including monospaced, can be found [here](https://github.com/IBM/plex/tree/master/packages).
+
+# Component
+The sylesheets of the Qt components are designed to make it similar to [Atlassian components](https://atlassian.design/components/).
+Always check for the Atlassian component usage guide in case of any doubt.
+

molde-0.1.19/README.md

@@ -0,0 +1,26 @@
+<div align="center">
+  <img height="90" src="logos/mold_horizontal_logo_dark_300dpi.png" alt="Logo" align="center">
+</div>
+
+# MOLDE
+**MO**PT **L**ightweight **De**sign (MOLDE) is a library created to standardize and make easier the creation and maintainance of internal products of the Multidisciplinary Optimization Group (MOPT).
+
+Here are the colors, icons, fonts and common interface components, that may be usefull for multiple MOPT projects.
+
+This is heavily inspired by [Carbon Design System](https://carbondesignsystem.com/), [Atlassian Design System](https://atlassian.design/), [Fast Design System](https://www.fast.design/), [Material Design](https://m3.material.io/) and [Bold Design System](https://bold.bridge.ufsc.br/pt/).
+
+# Colors 
+The color palettes are available [here](https://andrefpf.github.io/molde/).
+
+# Icons 
+A lot of free to use icons, from Material Design, are available [here](https://fonts.google.com/icons).
+Other icons may be necessary, and they will be made to match the same style.
+For consistency avoid using icons from other places.
+
+# Typeface
+The font choose for this system is [IBM Plex](https://www.ibm.com/plex/).
+The `.ttf` files for every version of the font, including monospaced, can be found [here](https://github.com/IBM/plex/tree/master/packages).
+
+# Component
+The sylesheets of the Qt components are designed to make it similar to [Atlassian components](https://atlassian.design/components/).
+Always check for the Atlassian component usage guide in case of any doubt.

molde-0.1.19/molde/__init__.py

@@ -0,0 +1,14 @@
+from pathlib import Path
+from qtpy.uic import loadUi
+from .colors import Color
+
+MOLDE_DIR = Path(__file__).parent
+UI_DIR = MOLDE_DIR / "ui_files/"
+
+def load_ui(uifile: str | Path, baseinstance):
+    from PySide6.QtCore import QDir
+        
+    working_directory = str(Path(uifile).parent)
+    working_directory = QDir(working_directory)
+
+    return loadUi(uifile, baseinstance, working_directory)

molde-0.1.19/molde/__main__.py

@@ -0,0 +1,81 @@
+import os, sys
+from PySide6.QtWidgets import QMainWindow, QApplication, QMessageBox, QLineEdit, QTableWidgetItem, QPushButton, QLabel, QSlider
+from PySide6.QtGui import QColor, QFont
+from PySide6.QtCore import Qt
+from time import time
+
+from vtkmodules.vtkFiltersSources import vtkCylinderSource
+from vtkmodules.vtkRenderingCore import vtkPolyDataMapper, vtkActor
+
+from molde import MOLDE_DIR, load_ui
+from molde import stylesheets
+from molde.render_widgets.common_render_widget import CommonRenderWidget
+
+
+class Example(QMainWindow):
+    def __init__(self, parent=None) -> None:
+        super().__init__()
+        load_ui(MOLDE_DIR / "stylesheets/mainwindow.ui", self, MOLDE_DIR / "stylesheets")
+        self.current_theme = "light"
+
+        self.change_theme_button.clicked.connect(self.change_theme)
+        # self.render_widget: CommonRenderWidget
+        # self.render_widget.create_axes()
+        # self.render_widget.create_scale_bar()
+        # self.render_widget.create_color_bar()
+        # self.render_widget.set_info_text("Hola\nque\ntal?")
+
+        cylinder = vtkCylinderSource()
+        cylinder.SetResolution(8)
+        cylinder_mapper = vtkPolyDataMapper()
+        cylinder_mapper.SetInputConnection(cylinder.GetOutputPort())
+        cylinder_actor = vtkActor()
+        cylinder_actor.SetMapper(cylinder_mapper)
+        # self.render_widget.add_actors(cylinder_actor)
+
+        self.botao1 = QPushButton()
+        self.label = QLabel("Olha o sapooo")
+        self.label.setProperty("type", "logo")
+        # font = QFont()
+        # font.setFamily("Bauhaus 93")
+        # self.label.setFont(font)
+        print(self.label.fontInfo().family())
+
+        self.slider = QSlider(Qt.Orientation.Horizontal)
+        self.slider.setValue(50)
+        self.botao1.setText("Olha a faca")
+        self.toolbar_2.addWidget(self.label)
+        self.toolbar_2.setDisabled(False)
+
+        item = QTableWidgetItem("fr")
+        item.setBackground(QColor("#FF0000"))  
+        self.tableWidget.setItem(0, 0, item) 
+        self.show()
+        
+    def change_theme(self):
+        if self.current_theme == "light":
+            self.current_theme = "dark"
+        else:
+            self.current_theme = "light"
+        
+        # self.render_widget.set_theme(self.current_theme)
+        stylesheets.set_theme(self.current_theme)
+    
+    def closeEvent(self, event):
+        close = QMessageBox.question(
+            self, 
+            "QUIT", 
+            "Would you like to close the application?", 
+            QMessageBox.Yes | QMessageBox.No
+        )
+        QApplication.quit()
+
+
+if __name__ == "__main__":
+    # Make the window scale evenly for every monitor
+    os.environ["QT_AUTO_SCREEN_SCALE_FACTOR"] = "1"
+
+    app = QApplication(sys.argv)
+    e = Example()
+    e.change_theme()
+    sys.exit(app.exec())

molde-0.1.19/molde/actors/__init__.py

@@ -0,0 +1,5 @@
+from .ghost_actor import GhostActor
+from .lines_actor import LinesActor
+from .round_points_actor import RoundPointsActor
+from .square_points_actor import SquarePointsActor
+from .common_symbols_actor import CommonSymbolsActorFixedSize, CommonSymbolsActorVariableSize

molde-0.1.19/molde/actors/common_symbols_actor.py

@@ -0,0 +1,148 @@
+from dataclasses import dataclass
+from typing import Callable
+
+from vtkmodules.vtkCommonCore import (
+    vtkDoubleArray,
+    vtkIntArray,
+    vtkPoints,
+    vtkUnsignedCharArray,
+)
+from vtkmodules.vtkCommonDataModel import vtkPolyData
+from vtkmodules.vtkRenderingCore import (
+    vtkActor,
+    vtkDistanceToCamera,
+    vtkGlyph3DMapper,
+    vtkRenderer,
+)
+
+from molde import Color
+
+Triple = tuple[float, float, float]
+
+
+@dataclass
+class Symbol:
+    shape_function: Callable
+    position: Triple
+    orientation: Triple
+    color: Color
+    scale: float
+
+
+class CommonSymbolsActor(vtkActor):
+    def __init__(self, *args, **kwargs):
+        self._symbols: list[Symbol] = list()
+
+    def add_symbol(
+        self,
+        shape_function: Callable,
+        position: Triple,
+        orientation: Triple,
+        color: Triple,
+        scale: float = 1,
+    ):
+        symbol = Symbol(
+            shape_function,
+            position,
+            orientation,
+            color,
+            scale,
+        )
+        self._symbols.append(symbol)
+
+    def clear_symbols(self):
+        self._symbols.clear()
+
+    def common_build(self):
+        self.data = vtkPolyData()
+        points = vtkPoints()
+
+        self.mapper: vtkGlyph3DMapper = vtkGlyph3DMapper()
+        self.SetMapper(self.mapper)
+
+        sources = vtkIntArray()
+        sources.SetName("sources")
+
+        rotations = vtkDoubleArray()
+        rotations.SetNumberOfComponents(3)
+        rotations.SetName("rotations")
+
+        scales = vtkDoubleArray()
+        scales.SetName("scales")
+
+        colors = vtkUnsignedCharArray()
+        colors.SetNumberOfComponents(4)
+        colors.SetName("colors")
+
+        shape_function_to_index = dict()
+        for symbol in self._symbols:
+            if symbol.shape_function not in shape_function_to_index:
+                index = len(shape_function_to_index)
+                shape_function_to_index[symbol.shape_function] = index
+                self.mapper.SetSourceData(index, symbol.shape_function())
+
+            points.InsertNextPoint(symbol.position)
+            rotations.InsertNextTuple(symbol.orientation)
+            colors.InsertNextTuple(symbol.color.to_rgba())
+            scales.InsertNextValue(symbol.scale)
+            sources.InsertNextValue(shape_function_to_index[symbol.shape_function])
+
+        self.data.SetPoints(points)
+        self.data.GetPointData().AddArray(sources)
+        self.data.GetPointData().AddArray(rotations)
+        self.data.GetPointData().AddArray(scales)
+        self.data.GetPointData().SetScalars(colors)
+
+    def set_zbuffer_offsets(self, factor: float, units: float):
+        """
+        This functions is usefull to make a object appear in front of the others.
+        If the object should never be hidden, the parameters should be set to
+        factor = 1 and offset = -66000.
+        """
+        self.mapper.SetResolveCoincidentTopologyToPolygonOffset()
+        self.mapper.SetRelativeCoincidentTopologyLineOffsetParameters(factor, units)
+        self.mapper.SetRelativeCoincidentTopologyPolygonOffsetParameters(factor, units)
+        self.mapper.SetRelativeCoincidentTopologyPointOffsetParameter(units)
+        self.mapper.Update()
+
+
+class CommonSymbolsActorFixedSize(CommonSymbolsActor):
+    def build(self):
+        self.common_build()
+
+        self.mapper.SetInputData(self.data)
+        self.mapper.SetSourceIndexArray("sources")
+        self.mapper.SetOrientationArray("rotations")
+        self.mapper.SetScaleArray("scales")
+        self.mapper.SourceIndexingOn()
+        self.mapper.ScalarVisibilityOn()
+        self.mapper.SetScaleModeToScaleByMagnitude()
+        self.mapper.SetScalarModeToUsePointData()
+        self.mapper.SetOrientationModeToDirection()
+        self.mapper.Update()
+
+
+class CommonSymbolsActorVariableSize(CommonSymbolsActor):
+    def __init__(self, renderer: vtkRenderer):
+        super().__init__()
+        self.renderer = renderer
+
+    def build(self):
+        self.common_build()
+
+        distance_to_camera = vtkDistanceToCamera()
+        distance_to_camera.SetInputData(self.data)
+        distance_to_camera.SetScreenSize(40)
+        distance_to_camera.SetRenderer(self.renderer)
+
+        self.mapper.SetInputConnection(distance_to_camera.GetOutputPort())
+        self.mapper.SetSourceIndexArray("sources")
+        self.mapper.SetOrientationArray("rotations")
+        self.mapper.SetScaleArray("DistanceToCamera")
+        self.mapper.SourceIndexingOn()
+        self.mapper.ScalarVisibilityOn()
+        self.mapper.SetScaleModeToScaleByMagnitude()
+        self.mapper.SetScalarModeToUsePointData()
+        self.mapper.SetOrientationModeToDirection()
+
+        self.mapper.Update()

molde-0.1.19/molde/actors/ghost_actor.py

@@ -0,0 +1,12 @@
+from vtkmodules.vtkRenderingCore import vtkActor
+
+
+class GhostActor(vtkActor):
+    def make_ghost(self):
+        self.GetProperty().LightingOff()
+        offset = -66000
+        mapper = self.GetMapper()
+        mapper.SetResolveCoincidentTopologyToPolygonOffset()
+        mapper.SetRelativeCoincidentTopologyLineOffsetParameters(0, offset)
+        mapper.SetRelativeCoincidentTopologyPolygonOffsetParameters(0, offset)
+        mapper.SetRelativeCoincidentTopologyPointOffsetParameter(offset)

molde-0.1.19/molde/actors/lines_actor.py

@@ -0,0 +1,31 @@
+from vtkmodules.vtkRenderingCore import vtkActor, vtkPolyDataMapper
+
+from molde.poly_data import LinesData
+
+
+class LinesActor(vtkActor):
+    def __init__(self, lines_list) -> None:
+        super().__init__()
+        self.lines_list = lines_list
+
+        self.build()
+
+    def build(self):
+        data = LinesData(self.lines_list)
+        mapper = vtkPolyDataMapper()
+        mapper.SetInputData(data)
+        self.SetMapper(mapper)
+        self.GetProperty().SetLineWidth(3)
+
+    def set_width(self, width):
+        self.GetProperty().SetLineWidth(width)
+
+    def appear_in_front(self, cond: bool):
+        # this offset is the Z position of the camera buffer.
+        # if it is -66000 the object stays in front of everything.
+        offset = -66000 if cond else 0
+        mapper = self.GetMapper()
+        mapper.SetResolveCoincidentTopologyToPolygonOffset()
+        mapper.SetRelativeCoincidentTopologyLineOffsetParameters(0, offset)
+        mapper.SetRelativeCoincidentTopologyPolygonOffsetParameters(0, offset)
+        mapper.SetRelativeCoincidentTopologyPointOffsetParameter(offset)

molde-0.1.19/molde/actors/round_points_actor.py

@@ -0,0 +1,7 @@
+from .square_points_actor import SquarePointsActor
+
+
+class RoundPointsActor(SquarePointsActor):
+    def __init__(self, points) -> None:
+        super().__init__(points)
+        self.GetProperty().RenderPointsAsSpheresOn()

molde-0.1.19/molde/actors/square_points_actor.py

@@ -0,0 +1,32 @@
+from vtkmodules.vtkRenderingCore import vtkActor, vtkPolyDataMapper
+
+from molde.poly_data import VerticesData
+
+
+class SquarePointsActor(vtkActor):
+    def __init__(self, points_list) -> None:
+        super().__init__()
+        self.points_list = points_list
+        self.build()
+
+    def build(self):
+        data = VerticesData(self.points_list)
+        mapper = vtkPolyDataMapper()
+        mapper.SetInputData(data)
+        self.SetMapper(mapper)
+
+        self.GetProperty().SetPointSize(20)
+        self.GetProperty().LightingOff()
+
+    def set_size(self, size):
+        self.GetProperty().SetPointSize(size)
+
+    def appear_in_front(self, cond: bool):
+        # this offset is the Z position of the camera buffer.
+        # if it is -66000 the object stays in front of everything.
+        offset = -66000 if cond else 0
+        mapper = self.GetMapper()
+        mapper.SetResolveCoincidentTopologyToPolygonOffset()
+        mapper.SetRelativeCoincidentTopologyLineOffsetParameters(0, offset)
+        mapper.SetRelativeCoincidentTopologyPolygonOffsetParameters(0, offset)
+        mapper.SetRelativeCoincidentTopologyPointOffsetParameter(offset)

molde-0.1.19/molde/colors/__init__.py

@@ -0,0 +1,2 @@
+from .color import Color
+from .color_names import *

molde-0.1.19/molde/colors/color.py

@@ -0,0 +1,265 @@
+import typing
+from qtpy.QtGui import QColor
+import numpy as np
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, init=False)
+class Color:
+    r: int
+    g: int
+    b: int
+    a: int
+
+    @typing.overload
+    def __new__(self, r: int, g: int, b: int, a: int = 255):
+        """
+        Initialize Colors with RGB or RGBA integer values ranging from 0 to 255.
+        """
+
+    @typing.overload
+    def __new__(self, r: float, g: float, b: float, a: float = 1.0):
+        """
+        Initialize Colors with RGB or RGBA floating values ranging from 0.0 to 1.0.
+        """
+
+    @typing.overload
+    def __new__(self, hexa: str):
+        """
+        Initialize colors from hex values.
+        The valid formats incluce RGB (#FF0000 for example)
+        and RGBA (#FF0000FF for example)
+        """
+
+    @typing.overload
+    def __new__(self, qcolor: QColor):
+        """
+        Initialize the color class with an instance of QColor
+        """
+
+    @typing.overload
+    def __new__(self, color: "Color"):
+        """
+        Initialize the color class with an instance it's own class
+        """
+
+    @typing.overload
+    def __new__(self):
+        """
+        Initialize an empty black color
+        """
+
+    def __new__(cls, *args):
+        """
+        Calls the appropriate constructor for the class according to the
+        number of arguments and their types.
+        """
+
+        all_int = all([isinstance(i, int) for i in args])
+        all_float = all([isinstance(i, float) for i in args])
+
+        if len(args) == 0:
+            return cls.from_rgba(0, 0, 0, 255)
+
+        elif len(args) == 1 and isinstance(args[0], str):
+            return cls.from_hex(*args)
+
+        elif len(args) == 1 and isinstance(args[0], QColor):
+            return cls.from_qcolor(*args)
+
+        elif len(args) == 1 and isinstance(args[0], Color):
+            return cls.from_color(*args)
+
+        elif len(args) in [3, 4] and all_int:
+            return cls.from_rgba(*args)
+
+        elif len(args) in [3, 4] and all_float:
+            return cls.from_rgba_f(*args)
+
+        else:
+            raise ValueError("Invalid input values")
+
+    @classmethod
+    def from_rgba(cls, r: int, g: int, b: int, a: int = 255) -> "Color":
+        """
+        This is the default constructor for the class.
+        All other constructors call this one.
+
+        Since "Color" should be imutable, we use "object.__setattr__" to bypass
+        the imutability just in the constructor.
+        """
+
+        obj = super().__new__(cls)
+        object.__setattr__(obj, "r", round(np.clip(r, 0, 255)))
+        object.__setattr__(obj, "g", round(np.clip(g, 0, 255)))
+        object.__setattr__(obj, "b", round(np.clip(b, 0, 255)))
+        object.__setattr__(obj, "a", round(np.clip(a, 0, 255)))
+        return obj
+
+    @classmethod
+    def from_rgb(self, r: int, g: int, b: int) -> "Color":
+        return self.from_rgba(r, g, b)
+
+    @classmethod
+    def from_rgb_f(self, r: float, g: float, b: float) -> "Color":
+        return self.from_rgba_f(r, g, b)
+
+    @classmethod
+    def from_rgba_f(self, r: float, g: float, b: float, a: float = 1) -> "Color":
+        return self.from_rgba(
+            round(r * 255),
+            round(g * 255),
+            round(b * 255),
+            round(a * 255),
+        )
+
+    @classmethod
+    def from_hex(self, color: str) -> "Color":
+        color = color.lstrip("#")
+        if len(color) == 6:
+            r, g, b = int(color[0:2], 16), int(color[2:4], 16), int(color[4:6], 16)
+            return self.from_rgb(r, g, b)
+        elif len(color) == 8:
+            r, g, b, a = int(color[0:2], 16), int(color[2:4], 16), int(color[4:6], 16), int(color[6:8], 16)
+            return self.from_rgba(r, g, b, a)
+        raise ValueError("Invalid hex color format")
+
+    @classmethod
+    def from_hsv(self, hue: float, saturation: float, value: float):
+        v = value / 100
+        s = saturation / 100
+
+        c = v * s
+        h = hue % 360 / 60
+        x = c * (1 - abs(h % 2 - 1))
+
+        if 0 <= h < 1:
+            r, g, b = c, x, 0
+        elif 1 <= h < 2:
+            r, g, b = x, c, 0
+        elif 2 <= h < 3:
+            r, g, b = 0, c, x
+        elif 3 <= h < 4:
+            r, g, b = 0, x, c
+        elif 4 <= h < 5:
+            r, g, b = x, 0, c
+        elif 5 <= h < 6:
+            r, g, b = c, 0, x
+        else:
+            r, g, b = 0, 0, 0
+
+        return self.from_rgb_f(
+            (r + v - c),
+            (g + v - c),
+            (b + v - c),
+        )
+
+    @classmethod
+    def from_qcolor(self, color: QColor) -> "Color":
+        return self.from_rgba(color.red(), color.green(), color.blue(), color.alpha())
+
+    @classmethod
+    def from_color(self, color: "Color"):
+        self.r = color.r
+        self.g = color.g
+        self.b = color.b
+        self.a = color.a
+        return self
+
+    def to_rgb(self) -> tuple[int, int, int]:
+        return (self.r, self.g, self.b)
+
+    def to_rgba(self) -> tuple[int, int, int, int]:
+        return (self.r, self.g, self.b, self.a)
+
+    def to_rgb_f(self) -> tuple[float, float, float]:
+        return ((self.r / 255), (self.g / 255), (self.b / 255))
+
+    def to_rgba_f(self) -> tuple[float, float, float, float]:
+        return ((self.r / 255), (self.g / 255), (self.b / 255), (self.a / 255))
+
+    def to_hex(self) -> str:
+        return f"#{self.r:02X}{self.g:02X}{self.b:02X}"
+
+    def to_hexa(self) -> str:
+        return f"#{self.r:02X}{self.g:02X}{self.b:02X}{self.a:02X}"
+
+    def to_hsv(self) -> tuple[int, int, int]:
+        r, g, b = self.to_rgb_f()
+        min_, mid_, max_ = sorted((r, g, b))
+        delta = max_ - min_
+
+        if delta == 0:
+            hue = 0
+        elif max_ == r:
+            hue = (g - b) / delta
+        elif max_ == g:
+            hue = (b - r) / delta + 2
+        elif max_ == b:
+            hue = (r - g) / delta + 4
+        else:
+            hue = 0
+
+        hue = round(60 * hue)
+        value = round(100 * max_)
+        saturation = round(100 * delta / max_) if (max_ != 0) else 0
+
+        return (
+            np.clip(0, 360, hue),
+            np.clip(0, 100, saturation),
+            np.clip(0, 100, value),
+        )
+
+    def to_qt(self) -> QColor:
+        return QColor(self.r, self.g, self.b, self.a)
+
+    def copy(self) -> "Color":
+        return Color(self.r, self.g, self.b, self.a)
+
+    def apply_factor(self, factor: float | int) -> "Color":
+        r = round(np.clip(self.r * factor, 0, 255))
+        g = round(np.clip(self.g * factor, 0, 255))
+        b = round(np.clip(self.b * factor, 0, 255))
+        return Color.from_rgba(r, g, b, self.a)
+
+    def with_brightness(self, brightness: int) -> "Color":
+        """
+        Percentage of brightness of the new color.
+        """
+        h, s, _ = self.to_hsv()
+        return self.from_hsv(h, s, brightness)
+
+    def with_saturation(self, saturation: int) -> "Color":
+        """
+        Percentage of brightness of the new color.
+        """
+        h, _, v = self.to_hsv()
+        return self.from_hsv(h, saturation, v)
+
+    def with_rgba(
+        self,
+        r: int | None = None,
+        g: int | None = None,
+        b: int | None = None,
+        a: int | None = None,
+    ) -> "Color":
+        return self.from_rgba(
+            r if (r is not None) else self.r,
+            g if (g is not None) else self.g,
+            b if (b is not None) else self.b,
+            a if (a is not None) else self.a,
+        )
+
+    def with_rgba_f(
+        self,
+        r: int | None = None,
+        g: int | None = None,
+        b: int | None = None,
+        a: int | None = None,
+    ) -> "Color":
+        return self.from_rgba_f(
+            r if (r is not None) else self.r,
+            g if (g is not None) else self.g,
+            b if (b is not None) else self.b,
+            a if (a is not None) else self.a,
+        )