# SceneSegmentationChannels

Source: https://www.nianticspatial.com/docs/api/swift/NSDK.struct-SceneSegmentationChannels/

SceneSegmentationChannels

---

## Declaration

struct SceneSegmentationChannels

## Summary

A set of semantic channels represented as a bitmask, matching the C SDK packed-channel layout.
Use this type wherever you need one or more semantic channels. It supports clean Swift syntax:

```swift
let channels: SceneSegmentationChannels = [.ground, .sky]
let single = SceneSegmentationChannels.grass
```

Bit positions 0-4 correspond to the C SDK channels: Sky=0, Ground=1, NaturalGround=2, ArtificialGround=3, Grass=4.

---

## Constructors

### Constructor

init()

#### Summary

Creates an empty option set.
This initializer creates an option set with a raw value of zero.

---

### Overload 1

init()

#### Summary

Empty set of channels (no bits set).

---

### Overload 2

init(arrayLiteral: Self.Element...)

#### Summary

Creates a set containing the elements of the given array literal.
Do not call this initializer directly. It is used by the compiler when
you use an array literal. Instead, create a new set using an array
literal as its value by enclosing a comma-separated list of values in
square brackets. You can use an array literal anywhere a set is expected
by the type context.
Here, a set of strings is created from an array literal holding only
strings:
    let ingredients: Set = ["cocoa beans", "sugar", "cocoa butter", "salt"]
    if ingredients.isSuperset(of: ["sugar", "salt"]) {
        print("Whatever it is, it's bound to be delicious!")
    }
    // Prints "Whatever it is, it's bound to be delicious!"

---

### Overload 3

init(arrayLiteral elements: SceneSegmentationChannels...)

#### Summary

Creates an instance initialized with the given elements.

---

### Overload 4

init(rawValue: UInt32)

#### Summary

Creates a new option set from the given raw value.
This initializer always succeeds, even if the value passed as rawValue
exceeds the static properties declared as part of the option set. This
example creates an instance of ShippingOptions with a raw value beyond
the highest element, with a bit mask that effectively contains all the
declared static members.
    let extraOptions = ShippingOptions(rawValue: 255)
    print(extraOptions.isStrictSuperset(of: .all))
    // Prints "true"

---

### Overload 5

init<S>(_ sequence: S) where S : Sequence, Self.Element == S.Element

#### Summary

Creates a new set from a finite sequence of items.
Use this initializer to create a new set from an existing sequence, like
an array or a range:
    let validIndices = Set(0..<7).subtracting([2, 4, 5])
    print(validIndices)
    // Prints "[6, 0, 1, 3]"

---

## Properties

| Name | Type | Summary |
| --- | --- | --- |
| static var allChannels | [SceneSegmentationChannels | All channels in SDK order (for pickers and iteration). |
| static let artificialGround | SceneSegmentationChannels | - |
| var channelDebugName | String | Human-readable name for this channel set (e.g. for pickers). Single channel returns one name; multiple are joined with "\|". |
| var debugDescription | String | A textual representation of this instance, suitable for debugging.Calling this property directly is discouraged. Instead, convert aninstance of any type to a string by using the `String(reflecting:)`initializer. This initializer works with any type, and uses the custom`debugDescription` property for types that conform to`CustomDebugStringConvertible`: struct Point: CustomDebugStringConvertible { let x: Int, y: Int var debugDescription: String { return "((x), (y))" } } let p = Point(x: 21, y: 30) let s = String(reflecting: p) print(s) // Prints "(21, 30)"The conversion of `p` to a string in the assignment to `s` uses the`Point` type's `debugDescription` property. |
| static let grass | SceneSegmentationChannels | - |
| static let ground | SceneSegmentationChannels | - |
| var hashValue | Int | - |
| var isEmpty | Bool | A Boolean value that indicates whether the set has no elements. |
| static let naturalGround | SceneSegmentationChannels | - |
| let rawValue | UInt32 | The corresponding value of the raw type.A new instance initialized with `rawValue` will be equivalent to thisinstance. For example: enum PaperSize: String { case A4, A5, Letter, Legal } let selectedSize = PaperSize.Letter print(selectedSize.rawValue) // Prints "Letter" print(selectedSize == PaperSize(rawValue: selectedSize.rawValue)!) // Prints "true" |
| static let sky | SceneSegmentationChannels | - |

---

## Methods

| Name | Type | Summary |
| --- | --- | --- |
| contains | Bool | Returns a Boolean value that indicates whether a given element is amember of the option set.This example uses the `contains(_:)` method to check whether next-dayshipping is in the `availableOptions` instance. let availableOptions = ShippingOptions.express if availableOptions.contains(.nextDay) { print("Next day shipping available") } // Prints "Next day shipping available" |
| mutating formIntersection | void | Removes all elements of this option set that are notalso present in the given set.This method is implemented as a `&amp;` (bitwise AND) operation on thetwo sets' raw values. |
| mutating formSymmetricDifference | void | Replaces this set with a new set containing all elementscontained in either this set or the given set, but not in both.This method is implemented as a `^` (bitwise XOR) operation on the twosets' raw values. |
| mutating formUnion | void | Inserts the elements of another set into this option set.This method is implemented as a `\|` (bitwise OR) operation on thetwo sets' raw values. |
| hash | void | - |
| @discardableResult mutating insert | (inserted: Bool, memberAfterInsert: Self.Element) | Adds the given element to the option set if it is not already a member.In the following example, the `.secondDay` shipping option is added tothe `freeOptions` option set if `purchasePrice` is greater than 50.0. Forthe `ShippingOptions` declaration, see the `OptionSet` protocoldiscussion. let purchasePrice = 87.55 var freeOptions: ShippingOptions = [.standard, .priority] if purchasePrice > 50 { freeOptions.insert(.secondDay) } print(freeOptions.contains(.secondDay)) // Prints "true" |
| intersection | Self | Returns a new option set with only the elements contained in both thisset and the given set.This example uses the `intersection(_:)` method to limit the availableshipping options to what can be used with a PO Box destination. // Can only ship standard or priority to PO Boxes let poboxShipping: ShippingOptions = [.standard, .priority] let memberShipping: ShippingOptions = [.standard, .priority, .secondDay] let availableOptions = memberShipping.intersection(poboxShipping) print(availableOptions.contains(.priority)) // Prints "true" print(availableOptions.contains(.secondDay)) // Prints "false" |
| isDisjoint | Bool | Returns a Boolean value that indicates whether the set has no members incommon with the given set.In the following example, the `employees` set is disjoint with the`visitors` set because no name appears in both sets. let employees: Set = ["Alicia", "Bethany", "Chris", "Diana", "Eric"] let visitors: Set = ["Marcia", "Nathaniel", "Olivia"] print(employees.isDisjoint(with: visitors)) // Prints "true" |
| isStrictSubset | Bool | Returns a Boolean value that indicates whether this set is a strictsubset of the given set.Set *A* is a strict subset of another set *B* if every member of *A* isalso a member of *B* and *B* contains at least one element that is not amember of *A*. let employees: Set = ["Alicia", "Bethany", "Chris", "Diana", "Eric"] let attendees: Set = ["Alicia", "Bethany", "Diana"] print(attendees.isStrictSubset(of: employees)) // Prints "true" // A set is never a strict subset of itself: print(attendees.isStrictSubset(of: attendees)) // Prints "false" |
| isStrictSuperset | Bool | Returns a Boolean value that indicates whether this set is a strictsuperset of the given set.Set *A* is a strict superset of another set *B* if every member of *B* isalso a member of *A* and *A* contains at least one element that is *not*a member of *B*. let employees: Set = ["Alicia", "Bethany", "Chris", "Diana", "Eric"] let attendees: Set = ["Alicia", "Bethany", "Diana"] print(employees.isStrictSuperset(of: attendees)) // Prints "true" // A set is never a strict superset of itself: print(employees.isStrictSuperset(of: employees)) // Prints "false" |
| isSubset | Bool | Returns a Boolean value that indicates whether the set is a subset ofanother set.Set *A* is a subset of another set *B* if every member of *A* is also amember of *B*. let employees: Set = ["Alicia", "Bethany", "Chris", "Diana", "Eric"] let attendees: Set = ["Alicia", "Bethany", "Diana"] print(attendees.isSubset(of: employees)) // Prints "true" |
| isSuperset | Bool | Returns a Boolean value that indicates whether the set is a superset ofthe given set.Set *A* is a superset of another set *B* if every member of *B* is also amember of *A*. let employees: Set = ["Alicia", "Bethany", "Chris", "Diana", "Eric"] let attendees: Set = ["Alicia", "Bethany", "Diana"] print(employees.isSuperset(of: attendees)) // Prints "true" |
| @discardableResult mutating remove | Self.Element? | Removes the given element and all elements subsumed by it.In the following example, the `.priority` shipping option is removed fromthe `options` option set. Attempting to remove the same shipping optiona second time results in `nil`, because `options` no longer contains`.priority` as a member. var options: ShippingOptions = [.secondDay, .priority] let priorityOption = options.remove(.priority) print(priorityOption == .priority) // Prints "true" print(options.remove(.priority)) // Prints "nil"In the next example, the `.express` element is passed to `remove(_:)`.Although `.express` is not a member of `options`, `.express` subsumesthe remaining `.secondDay` element of the option set. Therefore,`options` is emptied and the intersection between `.express` and`options` is returned. let expressOption = options.remove(.express) print(expressOption == .express) // Prints "false" print(expressOption == .secondDay) // Prints "true" |
| mutating subtract | void | Removes the elements of the given set from this set.In the following example, the elements of the `employees` set that arealso members of the `neighbors` set are removed. In particular, thenames `"Bethany"` and `"Eric"` are removed from `employees`. var employees: Set = ["Alicia", "Bethany", "Chris", "Diana", "Eric"] let neighbors: Set = ["Bethany", "Eric", "Forlani", "Greta"] employees.subtract(neighbors) print(employees) // Prints "["Diana", "Chris", "Alicia"]" |
| subtracting | Self | Returns a new set containing the elements of this set that do not occurin the given set.In the following example, the `nonNeighbors` set is made up of theelements of the `employees` set that are not elements of `neighbors`: let employees: Set = ["Alicia", "Bethany", "Chris", "Diana", "Eric"] let neighbors: Set = ["Bethany", "Eric", "Forlani", "Greta"] let nonNeighbors = employees.subtracting(neighbors) print(nonNeighbors) // Prints "["Diana", "Chris", "Alicia"]" |
| symmetricDifference | Self | Returns a new option set with the elements contained in this set or inthe given set, but not in both. |
| toChannelSet | [SceneSegmentationChannels] | Convert to an array of single-channel option sets (for iteration / display). |
| union | Self | Returns a new option set of the elements contained in this set, in thegiven set, or in both.This example uses the `union(_:)` method to add two more shipping optionsto the default set. let defaultShipping = ShippingOptions.standard let memberShipping = defaultShipping.union([.secondDay, .priority]) print(memberShipping.contains(.priority)) // Prints "true" |
| @discardableResult mutating update | Self.Element? | Inserts the given element into the set.If `newMember` is not contained in the set but subsumes current membersof the set, the subsumed members are returned. var options: ShippingOptions = [.secondDay, .priority] let replaced = options.update(with: .express) print(replaced == .secondDay) // Prints "true" |

---

## Operators

| Name | Type | Summary |
| --- | --- | --- |
| static func != | Bool | Returns a Boolean value indicating whether two values are not equal.Inequality is the inverse of equality. For any values `a` and `b`, `a != b`implies that `a == b` is `false`.This is the default implementation of the not-equal-to operator (`!=`)for any type that conforms to `Equatable`. |

---

## Relationships

conforms to:  Swift.OptionSet 

conforms to:  Swift.RawRepresentable 

conforms to:  Swift.Hashable 

conforms to:  Swift.Sendable 

conforms to:  Swift.CustomDebugStringConvertible 

conforms to:  Swift.ExpressibleByArrayLiteral 

conforms to:  Swift.SetAlgebra 

conforms to:  Swift.Equatable 

conforms to:  Swift.SendableMetatype